scikit-learn 中常用的评估模型

妖狐艹你老母 2022-05-20 01:51 190阅读 0赞

--------------------

![20200423153001126.PNG][]

## 一，scikit-learn中常用的评估模型 ##

### 1.评估分类模型： ###

![70][]

### 2.评估回归模型： ###

![70 1][]

## 二、常见模型评估解析： ##

### 1）.回归模型评估： ###

![70 2][]

•1.均方误差（Mean Squared Error，MSE）

![MSE = \\frac\{1\}\{n\}\\sum\_\{i=1\}^\{n\}(\\hat\{y\_\{i\}\}-y\_\{i\})^\{2\}][MSE _ _frac_1_n_sum_i_1_n_hat_y_i_-y_i_2]

•2.均方根误差（Root Mean Squared Error，RMSE）

RMSE是一个衡量回归模型误差率的常用公式。然而，它仅能比较误差是相同单位的模型

![70 3][]

•由于对误差E 进行平方，加强了数值大的误差在指标中的作用，从而提高了指标的灵敏性。

•3.平均绝对误差（Mean Absolute Error，MAE)

![70 4][]

•4.平均绝对百分误差（MeanAbsolute Percentage Error）

![70 5][]

•一般认为MAPE小于10时，预测精度高。

5.![R^\{2\}][R_2] 决定系数：对模型进行线性回归后，评价回归模型系数拟合优度。

决定系数是相关系数的平方。 相关系数是用来描述两个变量之间的线性关系的，但决定系数的适用范围更广，可以用于描述非线性或者有两个及两个以上自变量的相关关系。

表征因变量Y的变异中有多少百分比,可由控制的自变量X来解释.

> 表达式：![R^2=\\frac\{SSR\}\{SST\}=1-\\frac\{SSE\}\{SST\}][R_2_frac_SSR_SST_1-_frac_SSE_SST]
> 
> 其中：![SST=SSR+SSE][SST_SSR_SSE]
> 
> ![SSE=SS\_(res)=\\sum \_\{i=1\}^\{n\}(y\_i-f\_i)^2][SSE_SS_res_sum _i_1_n_y_i-f_i_2]
> 
> ![SST=SS\_(tot)=\\sum \_\{i=1\}^\{n\}(y\_i-\\overline\{y\})^2][SST_SS_tot_sum _i_1_n_y_i-_overline_y_2]

回归平方和：SSR(Sum of Squares for regression) = ESS (explained sum of squares)

残差平方和：SSE（Sum of Squares for Error） = RSS (residual sum of squares)  
总离差平方和：SST(Sum of Squares for total) = TSS(total sum of squares)  
　　 SSE+SSR=SST RSS+ESS=TSS

![format_png][]

意义：拟合优度越大，自变量对因变量的解释程度越高，自变量引起的变动占总变动的百分比高。观察点在回归直线附近越密集。

取值范围： 0-1

<table style="width:695px;"> 
 <tbody> 
  <tr> 
   <td style="vertical-align:middle;"> <p>判定系数</p> </td> 
   <td style="vertical-align:middle;"> <p>相关系数</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;"> <p>就模型而言</p> </td> 
   <td style="vertical-align:middle;"> <p>就两个变量而言</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;"> <p>说明解释变量对因变量的解释程度</p> </td> 
   <td style="vertical-align:middle;"> <p>度量两个变量线性依存程度。</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;"> <p>度量不对称的因果关系</p> </td> 
   <td style="vertical-align:middle;"> <p>度量不含因果关系的对称相关关系</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;"> <p>取值：[0,1]</p> </td> 
   <td style="vertical-align:middle;"> <p>取值：[－1,1]</p> </td> 
  </tr> 
 </tbody> 
</table>

参考：[百度百科][Link 1]

### •2)分类模型评估： ###

对于二分类问题，可将样例根据其真实类别和分类器预测类别划分为：（T,F表示预测的正确与错误性，P,N表示预测的正类和负类）

•真正例（TruePositive，TP）：真实类别为正例，预测类别为正例。

•假正例（FalsePositive，FP）：真实类别为负例，预测类别为正例。

•假负例（FalseNegative，FN）：真实类别为正例，预测类别为负例。

•真负例（TrueNegative，TN）：真实类别为负例，预测类别为负例。

•构建混淆矩阵（ConfusionMatrix）:

![70 6][]

•识别精确度（accuracy）

•Accuracy=(TP+FN)/(TP+TN+FP+FN)×100%

•准确率（precision）：

![70 7][]

•召回率（recall）：

![70 8][]

•

•F1值：精确度和召回率的调和平均值

![70 9][]

•precision 和 recall 都是越高越好。精确度和召回率都高时，F1 值也会高． F1 值在1时达到最佳值（完美的精确度和召回率），最差为0．在二元分类中，F1 是测试准确度的量度。

classification\_report 的主要参数：

主要参数: 
    y_true：1维数组，或标签指示器数组/稀疏矩阵，目标值。 
    y_pred：1维数组，或标签指示器数组/稀疏矩阵，分类器返回的估计值。 
    labels：array，shape = [n_labels]，报表中包含的标签索引的可选列表。 
    target_names：字符串列表，与标签匹配的可选显示名称（相同顺序）。 
    sample_weight：类似于shape = [n_samples]的数组，可选项，样本权重。 
    digits：int，输出浮点值的位数．

from sklearn.metrics import classification_report
    y_true = [0,1,2,2,1,0]
    y_pred = [0,2,0,2,1,0]
    
    target_names= ['class0','class1','class2']
    reports = classification_report(y_true, y_pred, target_names=target_names)  #生成分类的指标的文本报告
    print(reports)
    #输出结果
    #              precision    recall  f1-score   support
    # 
    #      class0       0.67      1.00      0.80         2    #support为真实label出现的次数
    #      class1       1.00      0.50      0.67         2
    #      class2       0.50      0.50      0.50         2
    # 
    # avg / total       0.72      0.67      0.66         6

### 计算方法： ###

先计算label 0：即reports的class0

> 计算precision准确率时，只看分类标签是 0 的预测值，如图有 3 个，再看其预测成功的个数 ，有2个，所以准确率为 0.67  
> 计算recall召回率时：只看分类标签是0 的真实值，如图有2 个，再看其预测成功的个数， 有2 个，所以召回率为 1

结合p 和 r 计算 F1值

同理：计算label 1 和label 2

### ROC-AUC曲线 ###

•AUC值为ROC曲线所覆盖的区域面积,显然,AUC越大,分类器分类效果越好。

•AUC的物理意义

•假设分类器的输出是样本属于正类的score（置信度），则AUC的物理意义为，任取一对（正、负）样本，正样本的score大于负样本的score的概率。

**1.ROC曲线：**接受者操作特征（receiveroperating characteristic）曲线代表每个点反映着对同一个信号刺激的感受性。ROC曲线和AUC常被用来评价一个二值分类器（binaryclassifier）的优劣。

![70 10][]

![70 11][]

•横轴FPR越大，代表预测正类中实际负类越多

> ![FPR= \\frac\{TN\}\{FP+TN\}][FPR_ _frac_TN_FP_TN]

•纵轴TPR（**召回率 Recall**）越大，代表预测正类中实际正类也越多

> ![TPR= \\frac\{TP\}\{TP+FN\}][TPR_ _frac_TP_TP_FN]

--------------------

•因此，曲线越靠近（0,1）点，越往对角线45度左上角偏，分类效果越好。

如何绘制ROC 曲线

![70 12][]

![70 13][]

当我们将threshold设置为1和0时，分别可以得到ROC曲线上的(0,0)和(1,1)两个点。将这些(FPR,TPR)对连接起来，就得到了ROC曲线。当threshold取值越多，ROC曲线越平滑。

其实，我们并不一定要得到每个测试样本是正样本的概率值，只要得到这个分类器对该测试样本的“评分值”即可（评分值并不一定在(0,1)区间）。评分越高，表示分类器越肯定地认为这个测试样本是正样本，而且同时使用各个评分值作为threshold。将评分值转化为概率更易于理解一些。

**2.AUC**（Areaunder roc curve）在ROC曲线下的面积，度量分类模型的好坏。

•由于ROC曲线一般都处于y=x这条直线的上方，所以AUC的取值范围在0.5和1之间。使用AUC值作为评价标准是因为很多时候ROC曲线并不能清晰的说明哪个分类器的效果更好，而作为一个数值，对应AUC更大的分类器效果更好。

•

•首先AUC值是一个概率值，当你随机挑选一个正样本以及一个负样本，当前的分类算法根据计算得到的Score值将这个正样本排在负样本前面的概率就是AUC值。当然，AUC值越大，当前的分类算法越有可能将正样本排在负样本前面，即能够更好的分类。

![70 14][]

> •判定AUC 曲线的优劣：
> 
> •.90-1= very good (A)
> 
> •.80-.90= good (B)
> 
> •.70-.80= not so good (C)
> 
> •.60-.70= poor (D)
> 
> •.50-.60= fail (F)

**•3.精度-召回率曲线PRC（precisionrecall curve）**：与ROC曲线不同的是：PRC曲线是往右上角靠拢效果较好。

![70 15][]

•适用场景：

1. 地震的预测  
对于地震的预测，我们希望的是RECALL非常高，也就是说每次地震我们都希望预测出来。这个时候我们可以牺牲PRECISION。情愿发出1000次警报，把10次地震都预测正确了；也不要预测100次对了8次漏了两次。  
2. 嫌疑人定罪  
基于不错怪一个好人的原则，对于嫌疑人的定罪我们希望是非常准确的。及时有时候放过了一些罪犯（recall低），但也是值得的。

### •4.如何避免过拟合： ###

•过拟合表现为在训练数据上的误差非常小，而在测试数据集上的误差反而增大。其中原因一般是模型过于复杂，过分去拟合数据的噪声和离群点，导致模型的泛化能力差，鲁棒性差。

•常见的解决办法：增大数据集，对模型进行正则化。

### •5.交叉验证： ###

交叉验证是在机器学习建立模型和验证模型参数时常用的办法。交叉验证，顾名思义，就是重复的使用数据，把得到的样本数据进行切分，组合为不同的训练集和测试集，用训练集来训练模型，用测试集来评估模型预测的好坏。

•K-Folds交叉验证：K层交叉验证是将原始数据随机分为K 个部分，在K 个部分中，选择1 个作为测试集，K-1 个作为训练集。将实验重复K 次，每次实验都从K 个部分选择1 个不同的作为测试集，最后对得到的K 个实验结果取平均。

#coding=gbk
    '''
    Created on 2018年7月10日
    
    @author: Administrator
    '''
    
    #交叉验证
    
    #1.留出法：直接将原始的数据集变换成2类互斥的两类，一部分为训练集，另一部分为验证集、
    #在sklearn中使用  train_test_split函数
    from sklearn.model_selection import train_test_split
    import numpy as np
    from sklearn import svm     #支持向量机
    from sklearn import datasets
    
    iris = datasets.load_iris()     #加载鸢尾花数据集
    print(iris.data.shape, iris.target.shape)   #(150, 4) (150,)
    
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, 
                                                        test_size = 0.2, random_state=666)  
    #test_size 表示测试集所占的比例
    
    print(x_train.shape, x_test.shape)       #(120, 4) (30, 4)
    print(y_train.shape, y_test.shape)      #(120,) (30,)
    
    svm_clf = svm.SVC(kernel='linear', C= 1).fit(x_train, y_train)
    print(svm_clf.score(x_test, y_test))    #    1.0 百分之百的预测成功率
    
    #2.交叉验证方法
    from sklearn.model_selection import KFold
    import numpy as np
    x = np.array([[1,2],[3,4],[5,6],[7,8]])
    y = np.array([1,2,3,4])
    
    kf = KFold(n_splits=2,random_state=666)     #n_splits 是指将数据输出多少份
    for train_index, test_index in kf.split(x):
        print('train_index:', train_index, 'test_index:',test_index)
    # train_index: [2 3] test_index: [0 1]
    # train_index: [0 1] test_index: [2 3]
    
    #当n_splits = 3 时，输出如下:
    # train_index: [2 3] test_index: [0 1]
    # train_index: [0 1 3] test_index: [2]
    # train_index: [0 1 2] test_index: [3]
    
        x_train, y_train = x[train_index],y[train_index]
        x_test , y_test = x[test_index], y[test_index]
    print(x_train,' ',y_train)
    print(x_test,' ',y_test)
    
    #2.2 RepeatedKFold p次k折交叉验证,RepeatedKFold方法可以控制交叉验证的次数。n_repeats
    from sklearn.model_selection import RepeatedKFold
    x1 = np.array([[1,2],[3,4],[5,6],[7,8]])
    y1 = np.array([1,2,3,4])
    
    rk = RepeatedKFold(n_splits=2, n_repeats=2, random_state=666)
    for train_index, test_index in rk.split(x1):
        print('train_index:',train_index,'test_index:', test_index)
    # train_index: [0 2] test_index: [1 3]
    # train_index: [1 3] test_index: [0 2]
    # train_index: [2 3] test_index: [0 1]
    # train_index: [0 1] test_index: [2 3]
    
    #3 留一法  LeaveOneOut 
    print('-----LeaveOneOut------')
    from sklearn.model_selection import LeaveOneOut
    
    x2 = np.array([1,2,3,4,5])
    
    loo = LeaveOneOut()
    for train_index, test_index in loo.split(x2):
        print('train_index:',train_index, 'test_index:', test_index)
    # train_index: [1 2 3 4] test_index: [0]
    # train_index: [0 2 3 4] test_index: [1]
    # train_index: [0 1 3 4] test_index: [2]
    # train_index: [0 1 2 4] test_index: [3]
    # train_index: [0 1 2 3] test_index: [4]    
    
    #3.2 LeavePOut 留p法
    #基本原理和留一法是一样的
    from sklearn.model_selection import LeavePOut
    
    lpo = LeavePOut(p=2)
    for train_index, test_index in lpo.split(x2):
        print('train_index:',train_index, 'test_index:',test_index)
    # train_index: [2 3 4] test_index: [0 1]
    # train_index: [1 3 4] test_index: [0 2]
    # train_index: [1 2 4] test_index: [0 3]        有10中取法
    # train_index: [1 2 3] test_index: [0 4]
    # train_index: [0 3 4] test_index: [1 2]
    # train_index: [0 2 4] test_index: [1 3]
    # train_index: [0 2 3] test_index: [1 4]
    # train_index: [0 1 4] test_index: [2 3]
    # train_index: [0 1 3] test_index: [2 4]
    # train_index: [0 1 2] test_index: [3 4]    
    
    #4.shuffleSplit 随机分配， 可以随机把数据打乱，然后分为训练集和测试集
    print('------shufflesplit------')
    
    from sklearn.model_selection import ShuffleSplit
    ss = ShuffleSplit(n_splits=4, random_state = 666, test_size=0.4)
    for train_index, test_index in ss.split(x2):
        print('train_index:',train_index,'test_index:',test_index)
    # train_index: [1 2 4] test_index: [3 0]
    # train_index: [0 2 1] test_index: [3 4]
    # train_index: [0 2 3] test_index: [4 1]
    # train_index: [1 2 4] test_index: [0 3]

参考：[柚子皮blog][blog]

[20200423153001126.PNG]: /images/20220520/502dcae36c7a4f0281708fd911eb004b.png
[70]: /images/20220520/9ebc427d24d24851815ba096b1639492.png
[70 1]: /images/20220520/59edbda9c87b4aa69aba83ec66d265fa.png
[70 2]: /images/20220520/8e1c9127c00442648f7d683e672a36c6.png
[MSE _ _frac_1_n_sum_i_1_n_hat_y_i_-y_i_2]: https://private.codecogs.com/gif.latex?MSE%20%3D%20%5Cfrac%7B1%7D%7Bn%7D%5Csum_%7Bi%3D1%7D%5E%7Bn%7D%28%5Chat%7By_%7Bi%7D%7D-y_%7Bi%7D%29%5E%7B2%7D
[70 3]: /images/20220520/8e0842659e764a59ba83f0b9c2aafd75.png
[70 4]: /images/20220520/418c834a4f1c4022af6596bb394f4011.png
[70 5]: /images/20220520/c5e7c9392db444f69d5da4c3b32cfd5f.png
[R_2]: https://private.codecogs.com/gif.latex?R%5E%7B2%7D
[R_2_frac_SSR_SST_1-_frac_SSE_SST]: https://private.codecogs.com/gif.latex?R%5E2%3D%5Cfrac%7BSSR%7D%7BSST%7D%3D1-%5Cfrac%7BSSE%7D%7BSST%7D
[SST_SSR_SSE]: https://private.codecogs.com/gif.latex?SST%3DSSR&plus;SSE
[SSE_SS_res_sum _i_1_n_y_i-f_i_2]: https://private.codecogs.com/gif.latex?SSE%3DSS_%28res%29%3D%5Csum%20_%7Bi%3D1%7D%5E%7Bn%7D%28y_i-f_i%29%5E2
[SST_SS_tot_sum _i_1_n_y_i-_overline_y_2]: https://private.codecogs.com/gif.latex?SST%3DSS_%28tot%29%3D%5Csum%20_%7Bi%3D1%7D%5E%7Bn%7D%28y_i-%5Coverline%7By%7D%29%5E2
[format_png]: /images/20220520/0cc90eabf7b04176b1e5e9e5a163dd9d.png
[Link 1]: https://baike.baidu.com/item/%E5%86%B3%E5%AE%9A%E7%B3%BB%E6%95%B0
[70 6]: /images/20220520/63c88d8cf65f46f68d025e4b754fb091.png
[70 7]: /images/20220520/08a2562534d64952933469e4055b9834.png
[70 8]: /images/20220520/889d7486a7194e439f13ee6b58078fe4.png
[70 9]: /images/20220520/60b09b46f875480caa35b6fff0bb37c5.png
[70 10]: /images/20220520/c445d94133a74ed3951db907ba5de3be.png
[70 11]: /images/20220520/01b6f709d42547c584df5496e555864d.png
[FPR_ _frac_TN_FP_TN]: https://private.codecogs.com/gif.latex?FPR%3D%20%5Cfrac%7BTN%7D%7BFP&plus;TN%7D
[TPR_ _frac_TP_TP_FN]: https://private.codecogs.com/gif.latex?TPR%3D%20%5Cfrac%7BTP%7D%7BTP&plus;FN%7D
[70 12]: /images/20220520/b2619a81aaa74cfea73d5f0e12a7bcdb.png
[70 13]: /images/20220520/42bebf3f0d034b47acb1ad03421b7058.png
[70 14]: /images/20220520/dec585c6d8e9441399a924b9ac40cc99.png
[70 15]: /images/20220520/c58eebc5e7ea4dcaa9eda3bacfe63fea.png
[blog]: https://blog.csdn.net/pipisorry/article/details/51788927