Scikit-learn：分类模型评估Model evaluation

骑猪看日落 2022-09-25 10:22 203阅读 0赞

http://[blog.csdn.net/pipisorry/article/details/52250760][blog.csdn.net_pipisorry_article_details_52250760]

## 模型评估Model evaluation: quantifying the quality of predictions ##

3 different approaches to evaluate the quality of predictions of a model:

*  Estimator score method: Estimators have a score method providing a default evaluation criterion for the problem they are designed to solve. This is not discussed on this page, but in each estimator’s documentation.
 *  Scoring parameter: Model-evaluation tools using [cross-validation][] (such as [cross\_validation.cross\_val\_score][cross_validation.cross_val_score]and [grid\_search.GridSearchCV][grid_search.GridSearchCV]) rely on an internal scoring strategy. This is discussed in the section [The scoring parameter: defining model evaluation rules][The scoring parameter_ defining model evaluation rules].
 *  Metric functions: The metrics module implements functions assessing prediction error for specific purposes. These metrics are detailed in sections on [Classification metrics][], [Multilabel ranking metrics][], [Regression metrics][] and [Clustering metrics][].

Finally, [Dummy estimators][] are useful to get a baseline value of those metrics for random predictions.

For “pairwise” metrics, between samples and not estimators or predictions, see the [Pairwise metrics, Affinities and Kernels][Pairwise metrics_ Affinities and Kernels] section.

## sklearn一般评估方法 ##

The `scoring` parameter: defining model evaluation rules

<table> 
 <thead> 
  <tr> 
   <th>Scoring</th> 
   <th>Function</th> 
   <th>Comment</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>Classification</strong></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>‘accuracy’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html#sklearn.metrics.accuracy_score" title="metrics.accuracy_score" rel="nofollow">metrics.accuracy_score</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>‘average_precision’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score" title="metrics.average_precision_score" rel="nofollow">metrics.average_precision_score</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>‘f1’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score" title="metrics.f1_score" rel="nofollow">metrics.f1_score</a></td> 
   <td>for binary targets</td> 
  </tr> 
  <tr> 
   <td>‘f1_micro’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score" title="metrics.f1_score" rel="nofollow">metrics.f1_score</a></td> 
   <td>micro-averaged</td> 
  </tr> 
  <tr> 
   <td>‘f1_macro’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score" title="metrics.f1_score" rel="nofollow">metrics.f1_score</a></td> 
   <td>macro-averaged</td> 
  </tr> 
  <tr> 
   <td>‘f1_weighted’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score" title="metrics.f1_score" rel="nofollow">metrics.f1_score</a></td> 
   <td>weighted average</td> 
  </tr> 
  <tr> 
   <td>‘f1_samples’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score" title="metrics.f1_score" rel="nofollow">metrics.f1_score</a></td> 
   <td>by multilabel sample</td> 
  </tr> 
  <tr> 
   <td>‘neg_log_loss’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.log_loss.html#sklearn.metrics.log_loss" title="metrics.log_loss" rel="nofollow">metrics.log_loss</a></td> 
   <td>requires <code>predict_proba</code> support</td> 
  </tr> 
  <tr> 
   <td>‘precision’ etc.</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html#sklearn.metrics.precision_score" title="metrics.precision_score" rel="nofollow">metrics.precision_score</a></td> 
   <td>suffixes apply as with ‘f1’</td> 
  </tr> 
  <tr> 
   <td>‘recall’ etc.</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html#sklearn.metrics.recall_score" title="metrics.recall_score" rel="nofollow">metrics.recall_score</a></td> 
   <td>suffixes apply as with ‘f1’</td> 
  </tr> 
  <tr> 
   <td>‘roc_auc’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html#sklearn.metrics.roc_auc_score" title="metrics.roc_auc_score" rel="nofollow">metrics.roc_auc_score</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>Clustering</strong></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>‘adjusted_rand_score’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.adjusted_rand_score.html#sklearn.metrics.adjusted_rand_score" title="metrics.adjusted_rand_score" rel="nofollow">metrics.adjusted_rand_score</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>Regression</strong></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>‘neg_mean_absolute_error’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_error.html#sklearn.metrics.mean_absolute_error" title="metrics.mean_absolute_error" rel="nofollow">metrics.mean_absolute_error</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>‘neg_mean_squared_error’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html#sklearn.metrics.mean_squared_error" title="metrics.mean_squared_error" rel="nofollow">metrics.mean_squared_error</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>‘neg_median_absolute_error’</td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.median_absolute_error.html#sklearn.metrics.median_absolute_error" title="metrics.median_absolute_error" rel="nofollow">metrics.median_absolute_error</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><span style="color:#ff0000;">‘r2’</span></td> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html#sklearn.metrics.r2_score" title="metrics.r2_score" rel="nofollow">metrics.r2_score</a></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

使用如cross\_val\_score(clf, X, y, scoring='neg\_log\_loss')

Note：

1 计算auc值的时候需要注意的一点是，sklearn.metric.roc\_auc\_score(y\_actual, y\_pred)才是计算ROC AUC的，而sklearn.metrics.auc(x,y)是计算折线与x轴之间的面积，x是折线上点的横坐标，y是折线上点的纵坐标。而且需要注意的是，y\_actual必须是二类的，不能是连续数值（如果是，那么就需要自己利用sklearn.metrics.auc写一个计算面积的函数了）。

2 precision\_score、recall\_score、f1\_score中的y\_pred必须是01的值，不能是连续值，否则报错。相反，roc\_auc\_score就需要连续值吧。

\[Common cases: predefined values[¶][Link 1]\]

### 自定义scoring函数 ###

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

**交叉验证自定义scoring函数**

def rocAucScorer(*args):
        '''
        自定义ROC-AUC评价指标rocAucScorer(clf, x_test, y_true)
        :param y_true: y_test真值
        :param x_test: x测试集
        '''
        from sklearn import metrics
        # y值比对函数
        fun = lambda yt, ys: metrics.roc_auc_score([1.0 if _ > 0.0 else 0.0 for _ in yt],
                                                   np.select([ys < 0.0, ys > 1.0, True],
                                                             [0.0, 1.0, ys]))
    
        return metrics.make_scorer(fun, greater_is_better=True)(*args)

\[Defining your scoring strategy from metric functions[¶][Link 2]\]

或者You can generate even more flexible model scorers by constructing your ownscoring object from scratch, without using the [make\_scorer][make_scorer] factory.For a callable to be a scorer, it needs to meet the protocol specified bythe following two rules:

*  It can be called with parameters `(estimator, X, y)`, where `estimator`is the model that should be evaluated, `X` is validation data, and `y` isthe ground truth target for `X` (in the supervised case) or `None` (in theunsupervised case).
 *  It returns a floating point number that quantifies the`estimator` prediction quality on `X`, with reference to `y`.Again, by convention higher numbers are better, so if your scorerreturns loss, that value should be negated.

def rocAucScorer(clf, x_test, y_true):
        '''
        自定义ROC-AUC评价指标
        :param y_true: y_test真值
        :param x_test: x测试集
        '''
        from sklearn import metrics
        ys = clf.predict(x_test)
        score = metrics.roc_auc_score([1.0 if _ > 0.0 else 0.0 for _ in y_true],
                                      np.select([ys < 0.0, ys > 1.0, True],
                                                [0.0, 1.0, ys]))
        return score

\[Implementing your own scoring object[¶][Link 3]\]

[皮皮blog][blog]

# 分类模型评估 #

### 分类模型评估方法 ###

Some of these are restricted to the binary classification case:

<table> 
 <tbody> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html#sklearn.metrics.matthews_corrcoef" title="matthews_corrcoef" rel="nofollow">matthews_corrcoef</a>(y_true,&nbsp;y_pred[,&nbsp;...])</td> 
   <td>Compute the Matthews correlation coefficient (MCC) for binary classes</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve" title="precision_recall_curve" rel="nofollow">precision_recall_curve</a>(y_true,&nbsp;probas_pred)</td> 
   <td>Compute precision-recall pairs for different probability thresholds</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html#sklearn.metrics.roc_curve" title="roc_curve" rel="nofollow">roc_curve</a>(y_true,&nbsp;y_score[,&nbsp;pos_label,&nbsp;...])</td> 
   <td>Compute Receiver operating characteristic (ROC)</td> 
  </tr> 
 </tbody> 
</table>

Others also work in the multiclass case:

<table> 
 <tbody> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.cohen_kappa_score.html#sklearn.metrics.cohen_kappa_score" title="cohen_kappa_score" rel="nofollow">cohen_kappa_score</a>(y1,&nbsp;y2[,&nbsp;labels,&nbsp;weights])</td> 
   <td>Cohen’s kappa: a statistic that measures inter-annotator agreement.</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html#sklearn.metrics.confusion_matrix" title="confusion_matrix" rel="nofollow">confusion_matrix</a>(y_true,&nbsp;y_pred[,&nbsp;labels,&nbsp;...])</td> 
   <td>Compute confusion matrix to evaluate the accuracy of a classification</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.hinge_loss.html#sklearn.metrics.hinge_loss" title="hinge_loss" rel="nofollow">hinge_loss</a>(y_true,&nbsp;pred_decision[,&nbsp;labels,&nbsp;...])</td> 
   <td>Average hinge loss (non-regularized)</td> 
  </tr> 
 </tbody> 
</table>

Some also work in the multilabel case:

<table> 
 <tbody> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html#sklearn.metrics.accuracy_score" title="accuracy_score" rel="nofollow">accuracy_score</a>(y_true,&nbsp;y_pred[,&nbsp;normalize,&nbsp;...])</td> 
   <td>Accuracy classification score.</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report" title="classification_report" rel="nofollow">classification_report</a>(y_true,&nbsp;y_pred[,&nbsp;...])</td> 
   <td>Build a text report showing the main classification metrics</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score" title="f1_score" rel="nofollow">f1_score</a>(y_true,&nbsp;y_pred[,&nbsp;labels,&nbsp;...])</td> 
   <td>Compute the F1 score, also known as balanced F-score or F-measure</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.fbeta_score.html#sklearn.metrics.fbeta_score" title="fbeta_score" rel="nofollow">fbeta_score</a>(y_true,&nbsp;y_pred,&nbsp;beta[,&nbsp;labels,&nbsp;...])</td> 
   <td>Compute the F-beta score</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.hamming_loss.html#sklearn.metrics.hamming_loss" title="hamming_loss" rel="nofollow">hamming_loss</a>(y_true,&nbsp;y_pred[,&nbsp;labels,&nbsp;...])</td> 
   <td>Compute the average Hamming loss.</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.jaccard_similarity_score.html#sklearn.metrics.jaccard_similarity_score" title="jaccard_similarity_score" rel="nofollow">jaccard_similarity_score</a>(y_true,&nbsp;y_pred[,&nbsp;...])</td> 
   <td>Jaccard similarity coefficient score</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.log_loss.html#sklearn.metrics.log_loss" title="log_loss" rel="nofollow">log_loss</a>(y_true,&nbsp;y_pred[,&nbsp;eps,&nbsp;normalize,&nbsp;...])</td> 
   <td>Log loss, aka logistic loss or cross-entropy loss.</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_fscore_support.html#sklearn.metrics.precision_recall_fscore_support" title="precision_recall_fscore_support" rel="nofollow">precision_recall_fscore_support</a>(y_true,&nbsp;y_pred)</td> 
   <td>Compute precision, recall, F-measure and support for each class</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html#sklearn.metrics.precision_score" title="precision_score" rel="nofollow">precision_score</a>(y_true,&nbsp;y_pred[,&nbsp;labels,&nbsp;...])</td> 
   <td>Compute the precision</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html#sklearn.metrics.recall_score" title="recall_score" rel="nofollow">recall_score</a>(y_true,&nbsp;y_pred[,&nbsp;labels,&nbsp;...])</td> 
   <td>Compute the recall</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.zero_one_loss.html#sklearn.metrics.zero_one_loss" title="zero_one_loss" rel="nofollow">zero_one_loss</a>(y_true,&nbsp;y_pred[,&nbsp;normalize,&nbsp;...])</td> 
   <td>Zero-one classification loss.</td> 
  </tr> 
 </tbody> 
</table>

And some work with binary and multilabel (but not multiclass) problems:

<table> 
 <tbody> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score" title="average_precision_score" rel="nofollow">average_precision_score</a>(y_true,&nbsp;y_score[,&nbsp;...])</td> 
   <td>Compute average precision (AP) from prediction scores</td> 
  </tr> 
  <tr> 
   <td><a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html#sklearn.metrics.roc_auc_score" title="roc_auc_score" rel="nofollow">roc_auc_score</a>(y_true,&nbsp;y_score[,&nbsp;average,&nbsp;...])</td> 
   <td>Compute Area Under the Curve (AUC) from prediction scores</td> 
  </tr> 
 </tbody> 
</table>

\[[Classification metrics][]\]

## 分类准确率（Classification accuracy） ##

# calculate accuracy
    from sklearn import metrics
    print metrics.accuracy_score(y_test, y_pred_class)
    0.692708333333

### 分类准确率分数 ###

是指所有分类正确的百分比。

### 空准确率（null accuracy） ###

是指当模型总是预测比例较高的类别，那么其正确的比例是多少。

# examine the class distribution of the testing set (using a Pandas Series method)
    y_test.value_counts()

0    130
    1     62
    dtype: int64

# calculate the percentage of ones
    y_test.mean()

0.32291666666666669

# calculate the percentage of zeros
    1 - y_test.mean()

0.67708333333333326

# calculate null accuracy(for binary classification problems coded as 0/1)
    max(y_test.mean(), 1-y_test.mean())

0.67708333333333326

我们看到空准确率是68%，而分类准确率是69%，这说明该分类准确率并不是很好的模型度量方法，分类准确率的一个缺点是其不能表现任何有关测试数据的潜在分布。

# calculate null accuracy (for multi-class classification problems)
    y_test.value_counts().head(1) / len(y_test)

0    0.677083
    dtype: float64

比较真实和预测的类别响应值：

# print the first 25 true and predicted responses
    print "True:", y_test.values[0:25]
    print "Pred:", y_pred_class[0:25]

True: [1 0 0 1 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0]
    Pred: [0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0]

从上面真实值和预测值的比较中可以看出，当正确的类别是0时，预测的类别基本都是0；当正确的类别是1时，预测的类别大都不是1。换句话说，该训练的模型大都在比例较高的那项类别的预测中预测正确，而在另外一中类别的预测中预测失败，而我们没法从分类准确率这项指标中发现这个问题。

分类准确率这一衡量分类器的标准比较容易理解，但是它不能告诉你响应值的潜在分布，并且它也不能告诉你分类器犯错的类型。接下来介绍的混淆矩阵可以识别这个问题。

## 基于混淆矩阵的评估度量 ##

### 混淆矩阵 ###

混淆矩阵赋予一个分类器性能表现更全面的认识，同时它通过计算各种分类度量，指导你进行模型选择。

# IMPORTANT: first argument is true values, second argument is predicted values
    print metrics.confusion_matrix(y_test, y_pred_class)
    [[118  12]
     [ 47  15]]

![Center][]

*  真阳性（True Positive，TP）：指被分类器正确分类的正例数据
 *  真阴性（True Negative，TN）：指被分类器正确分类的负例数据
 *  假阳性（False Positive，FP）：被错误地标记为正例数据的负例数据
 *  假阴性（False Negative，FN）：被错误地标记为负例数据的正例数据

### 准确率、识别率（Classification Accuracy）：分类器正确分类的比例 ###

print (TP+TN) / float(TP+TN+FN+FP)
    print metrics.accuracy_score(y_test, y_pred_class)

**错误率、误分类率（Classification Error）：分类器误分类的比例**

print (FP+FN) / float(TP+TN+FN+FP)
    print 1-metrics.accuracy_score(y_test, y_pred_class)

考虑类不平衡问题，其中感兴趣的主类是稀少的。即数据集的分布反映负类显著地占多数，而正类占少数。故面对这种问题，需要其他的度量，评估分类器正确地识别正例数据的情况和正确地识别负例数据的情况。

### 召回率（Recall），也称为真正例识别率、灵敏性（Sensitivity）、查全率：正确识别的正例数据在实际正例数据中的百分比 ###

print TP / float(TP+FN)
    print metrics.recall_score(y_test, y_pred_class)

**特效性（Specificity），也称为真负例率：正确识别的负例数据在实际负例数据中的百分比**

print TN / float(TN+FP)

**假阳率（False Positive Rate）：实际值是负例数据，预测错误的百分比**

print FP / float(TN+FP)
    specificity = TN / float(TN+FP)
    print 1 - specificity

### 精度（Precision）：看做精确性的度量，即标记为正类的数据实际为正例的百分比 ###

print TP / float(TP+FP)
    precision = metrics.precision_score(y_test, y_pred_class)
    print precision

### F度量（又称为F1分数或F分数），是使用精度和召回率的方法组合到一个度量上 ###

*F*=2∗ *p* *r* *e* *c* *i* *s* *i* *o* *n*∗ *r* *e* *c* *a* *l* *l* *p* *r* *e* *c* *i* *s* *i* *o* *n*\+ *r* *e* *c* *a* *l* *l*

*F* *β*=(1+ *β*2)∗ *p* *r* *e* *c* *i* *s* *i* *o* *n*∗ *r* *e* *c* *a* *l* *l* *β*2∗ *p* *r* *e* *c* *i* *s* *i* *o* *n*\+ *r* *e* *c* *a* *l* *l*

*F*度量是精度和召回率的调和均值，它赋予精度和召回率相等的权重。

*F**β*度量是精度和召回率的加权度量，它赋予召回率权重是赋予精度的β倍。

print (2*precision*recall) / (precision+recall)
    print metrics.f1_score(y_test, y_pred_class)

### sklearn评估报告 ###

from sklearn import metrics
    # summarize the fit of the model
    print(metrics.classification_report(expected, predicted))

计算的结果中有这些指标

precision    recall  f1-score   support  
          0       0.96      0.77      0.86      4950  
          1       0.18      0.62      0.28       392  
avg / total       0.90      0.76      0.81      5342

Note: 如0.18就是正例1对应的precision。

## Precision-Recall曲线 ##

sklearn.metrics.precision\_recall\_curve(y\_true, probas\_pred, pos\_label=None, sample\_weight=None)

参数

**y\_true** : array, shape = \[n\_samples\]

True targets of binary classification in range \{-1, 1\} or \{0, 1\}. 也就是二分类的binary。

**probas\_pred** : array, shape = \[n\_samples\]

Estimated probabilities or decision function. 必须是连续的continuous.

def plotPR(yt, ys, title=None):
        '''
        绘制precision-recall曲线
        :param yt: y真值
        :param ys: y预测值, recall,
        '''
        import seaborn
        from sklearn import metrics
        from matplotlib import pyplot as plt
        precision, recall, thresholds = metrics.precision_recall_curve(yt, ys)
    
        plt.plot(precision, recall, 'darkorange', lw=1, label='x=precision')
        plt.plot(recall, precision, 'blue', lw=1, label='x=recall')
        plt.legend(loc='best')
        plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
        plt.title('Precision-Recall curve for %s' % title)
        plt.ylabel('Recall')
        plt.xlabel('Precision')
        plt.show()
        plt.savefig(os.path.join(CWD, 'middlewares/pr-' + title + '.png'))

\[ [sklearn.metrics.precision\_recall\_curve][sklearn.metrics.precision_recall_curve]\]

## ROC曲线和AUC ##

\[[机器学习模型的评价指标和方法 ][Link 4]:ROC曲线和AUC\]

sklearn.metrics.roc\_curve(y\_true, y\_score, pos\_label=None, sample\_weight=None, drop\_intermediate=True)

参数

**y\_true** : array, shape = \[n\_samples\]

True targets of binary classification in range \{-1, 1\} or \{0, 1\}. 也就是二分类的binary。

**y\_score** : array, shape = \[n\_samples\]

Target scores, can either be probability estimates of the positiveclass, confidence values, or non-thresholded measure of decisions(as returned by “decision\_function” on some classifiers).应该也必须是连续的continuous.

绘制实现

def plotRUC(yt, ys, title=None):
        '''
        绘制ROC-AUC曲线
        :param yt: y真值
        :param ys: y预测值
        '''
        from sklearn import metrics
        from matplotlib import pyplot as plt
        f_pos, t_pos, thresh = metrics.roc_curve(yt, ys)
        auc_area = metrics.auc(f_pos, t_pos)
        print('auc_area: {}'.format(auc_area))
    
        plt.plot(f_pos, t_pos, 'darkorange', lw=2, label='AUC = %.2f' % auc_area)
        plt.legend(loc='lower right')
        plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
        plt.title('ROC-AUC curve for %s' % title)
        plt.ylabel('True Pos Rate')
        plt.xlabel('False Pos Rate')
        plt.show()
        plt.savefig(os.path.join(CWD, 'middlewares/roc-' + title + '.png'))

\[ [roc\_curve][roc_curve](y\_true, y\_score\[, pos\_label, ...\])\]

\[[roc\_auc\_score][roc_auc_score](y\_true, y\_score\[, average, ...\])\]

## 使用什么度量取决于具体的业务要求 ##

*  垃圾邮件过滤器：优先优化精度或者特效性，因为该应用对假阳性（非垃圾邮件被放进垃圾邮件箱）的要求高于对假阴性（垃圾邮件被放进正常的收件箱）的要求
 *  欺诈交易检测器：优先优化灵敏度，因为该应用对假阴性（欺诈行为未被检测）的要求高于假阳性（正常交易被认为是欺诈）的要求

\[[【scikit-learn】评估分类器性能的度量，像混淆矩阵、ROC、AUC等][scikit-learn_ROC_AUC]\]

[皮皮blog][blog]

from: [Scikit-learn：模型评估Model evaluation\_皮皮blog-CSDN博客][blog.csdn.net_pipisorry_article_details_52250760]

ref: \[[机器学习模型的评价指标和方法 ][Link 4]\]

\[[scikit-learn User Guide][]\]

\[[Model selection and evaluation][]\]

\[[3.3. Model evaluation: quantifying the quality of predictions][3.3. Model evaluation_ quantifying the quality of predictions]\]\*

\[[3.5. Validation curves: plotting scores to evaluate models][3.5. Validation curves_ plotting scores to evaluate models]\]\*

[blog.csdn.net_pipisorry_article_details_52250760]: http://blog.csdn.net/pipisorry/article/details/52250760
[cross-validation]: http://scikit-learn.org/stable/modules/cross_validation.html#cross-validation
[cross_validation.cross_val_score]: http://scikit-learn.org/stable/modules/generated/sklearn.cross_validation.cross_val_score.html#sklearn.cross_validation.cross_val_score
[grid_search.GridSearchCV]: http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.GridSearchCV.html#sklearn.grid_search.GridSearchCV
[The scoring parameter_ defining model evaluation rules]: http://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter
[Classification metrics]: http://scikit-learn.org/stable/modules/model_evaluation.html#classification-metrics
[Multilabel ranking metrics]: http://scikit-learn.org/stable/modules/model_evaluation.html#multilabel-ranking-metrics
[Regression metrics]: http://scikit-learn.org/stable/modules/model_evaluation.html#regression-metrics
[Clustering metrics]: http://scikit-learn.org/stable/modules/model_evaluation.html#clustering-metrics
[Dummy estimators]: http://scikit-learn.org/stable/modules/model_evaluation.html#dummy-estimators
[Pairwise metrics_ Affinities and Kernels]: http://scikit-learn.org/stable/modules/metrics.html#metrics
[Link 1]: http://scikit-learn.org/stable/modules/model_evaluation.html#common-cases-predefined-values
[Link 2]: http://scikit-learn.org/stable/modules/model_evaluation.html#defining-your-scoring-strategy-from-metric-functions
[make_scorer]: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html#sklearn.metrics.make_scorer
[Link 3]: http://scikit-learn.org/stable/modules/model_evaluation.html#implementing-your-own-scoring-object
[blog]: http://blog.csdn.net/pipisorry
[Center]: /images/20220718/eac9dd8b73dc45d8b3c9ca2b74201c1e.png
[sklearn.metrics.precision_recall_curve]: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve
[Link 4]: http://blog.csdn.net/pipisorry/article/details/52574156
[roc_curve]: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html#sklearn.metrics.roc_curve
[roc_auc_score]: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html#sklearn.metrics.roc_auc_score
[scikit-learn_ROC_AUC]: http://blog.csdn.net/jasonding1354/article/details/50562543
[scikit-learn User Guide]: http://scikit-learn.org/stable/user_guide.html#
[Model selection and evaluation]: http://scikit-learn.org/stable/model_selection.html
[3.3. Model evaluation_ quantifying the quality of predictions]: http://scikit-learn.org/stable/modules/model_evaluation.html#
[3.5. Validation curves_ plotting scores to evaluate models]: http://scikit-learn.org/stable/modules/learning_curve.html