数据分割：留出法train_test_split、留一法LeaveOneOut、GridSearchCV(交叉验证法+网格搜索)、自助法

偏执的太偏执、 2023-07-07 08:45 30阅读 0赞

# ![20191009191333910.png][][日萌社][Link 1] #

[人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）][AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]

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

# 1.10 交叉验证，网格搜索 #

## 学习目标 ##

*  目标
    
     *  知道交叉验证、网格搜索的概念
     *  会使用交叉验证、网格搜索优化训练模型

## 1 什么是交叉验证(cross validation) ##

交叉验证：将拿到的训练数据，分为训练和验证集。以下图为例：将数据分成4份，其中一份作为验证集。然后经过4次(组)的测试，每次都更换不同的验证集。即得到4组模型的结果，取平均值作为最终结果。又称4折交叉验证。

### 1.1 分析 ###

我们之前知道数据分为训练集和测试集，但是**为了让从训练得到模型结果更加准确。**做以下处理

*  训练集：训练集+验证集
 *  测试集：测试集

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70][]

### 1.2 为什么需要交叉验证 ###

交叉验证目的：**为了让被评估的模型更加准确可信**

**问题：这个只是让被评估的模型更加准确可信，那么怎么选择或者调优参数呢？**

## 2 什么是网格搜索(Grid Search) ##

通常情况下，**有很多参数是需要手动指定的（如k-近邻算法中的K值），这种叫超参数**。但是手动过程繁杂，所以需要对模型预设几种超参数组合。**每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建立模型。**

![20200222114141284.png][]

## 3 交叉验证，网格搜索（模型选择与调优）API： ##

*  sklearn.model\_selection.GridSearchCV(estimator, param\_grid=None,cv=None)
    
     *  对估计器的指定参数值进行详尽搜索
     *  estimator：估计器对象
     *  param\_grid：估计器参数(dict)\{“n\_neighbors”:\[1,3,5\]\}
     *  cv：指定几折交叉验证
     *  
     *  fit：输入训练数据
     *  score：准确率
     *  结果分析：
        
         *  best*score\_\_:在交叉验证中验证的最好结果*
         *  best*estimator*：最好的参数模型
         *  cv*results*:每次交叉验证后的验证集准确率结果和训练集准确率结果

## 4 鸢尾花案例增加K值调优 ##

*  使用GridSearchCV构建估计器

# 1、获取数据集
    iris = load_iris()
    # 2、数据基本处理 -- 划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
    # 3、特征工程：标准化
    # 实例化一个转换器类
    transfer = StandardScaler()
    # 调用fit_transform
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4、KNN预估器流程
    #  4.1 实例化预估器类
    estimator = KNeighborsClassifier()
    
    # 4.2 模型选择与调优——网格搜索和交叉验证
    # 准备要调的超参数
    param_dict = {"n_neighbors": [1, 3, 5]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=3)
    # 4.3 fit数据进行训练
    estimator.fit(x_train, y_train)
    # 5、评估模型效果
    # 方法a：比对预测结果和真实值
    y_predict = estimator.predict(x_test)
    print("比对预测结果和真实值：\n", y_predict == y_test)
    # 方法b：直接计算准确率
    score = estimator.score(x_test, y_test)
    print("直接计算准确率：\n", score)

*  然后进行评估查看最终选择的结果和交叉验证的结果

print("在交叉验证中验证的最好结果：\n", estimator.best_score_)
    print("最好的参数模型：\n", estimator.best_estimator_)
    print("每次交叉验证后的准确率结果：\n", estimator.cv_results_)

*  最终结果

比对预测结果和真实值：
     [ True  True  True  True  True  True  True False  True  True  True  True
      True  True  True  True  True  True False  True  True  True  True  True
      True  True  True  True  True  True  True  True  True  True  True  True
      True  True]
    直接计算准确率：
     0.947368421053
    在交叉验证中验证的最好结果：
     0.973214285714
    最好的参数模型：
     KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
               metric_params=None, n_jobs=1, n_neighbors=5, p=2,
               weights='uniform')
    每次交叉验证后的准确率结果：
     {'mean_fit_time': array([ 0.00114751,  0.00027037,  0.00024462]), 'std_fit_time': array([  1.13901511e-03,   1.25300249e-05,   1.11011951e-05]), 'mean_score_time': array([ 0.00085751,  0.00048693,  0.00045625]), 'std_score_time': array([  3.52785082e-04,   2.87650037e-05,   5.29673344e-06]), 'param_n_neighbors': masked_array(data = [1 3 5],
                 mask = [False False False],
           fill_value = ?)
    , 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}], 'split0_test_score': array([ 0.97368421,  0.97368421,  0.97368421]), 'split1_test_score': array([ 0.97297297,  0.97297297,  0.97297297]), 'split2_test_score': array([ 0.94594595,  0.89189189,  0.97297297]), 'mean_test_score': array([ 0.96428571,  0.94642857,  0.97321429]), 'std_test_score': array([ 0.01288472,  0.03830641,  0.00033675]), 'rank_test_score': array([2, 3, 1], dtype=int32), 'split0_train_score': array([ 1.        ,  0.95945946,  0.97297297]), 'split1_train_score': array([ 1.        ,  0.96      ,  0.97333333]), 'split2_train_score': array([ 1.  ,  0.96,  0.96]), 'mean_train_score': array([ 1.        ,  0.95981982,  0.96876877]), 'std_train_score': array([ 0.        ,  0.00025481,  0.0062022 ])}

## 5 总结 ##

*  交叉验证【知道】
    
     *  定义：
        
         *  将拿到的训练数据，分为训练和验证集
         *  \*折交叉验证
     *  分割方式：
        
         *  训练集：训练集+验证集
         *  测试集：测试集
     *  为什么需要交叉验证
        
         *  为了让被评估的模型更加准确可信
         *  注意：交叉验证不能提高模型的准确率
 *  网格搜索【知道】
    
     *  超参数:
        
         *  sklearn中,需要手动指定的参数,叫做超参数
     *  网格搜索就是把这些超参数的值,通过字典的形式传递进去,然后进行选择最优值
 *  api【知道】
    
     *  sklearn.model\_selection.GridSearchCV(estimator, param\_grid=None,cv=None)
        
         *  estimator -- 选择了哪个训练模型
         *  param\_grid -- 需要传递的超参数
         *  cv -- 几折交叉验证

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

# 第一章知识补充：再议数据分割 #

前面已经讲过，我们可**通过实验测试来对学习器的泛化误差进行评估并进而做出选择**。

为此，需使用一个“测试集”( testing set)来测试学习器对新样本的判别能力，然后**以测试集上的“测试误差” (testing error)作为泛化误差的近似。**

通常我们假设测试样本也是**从样本真实分布中独立同分布采样而得**。但需注意的是，**测试集应该尽可能与训练集互斥。**

> 互斥，即测试样本尽量不在训练集中出现、未在训练过程中使用过。

测试样本为什么要尽可能不出现在训练集中呢？为理解这一点，不妨考虑这样一个场景:

> 老师出了10道习题供同学们练习，考试时老师又用同样的这10道题作为试题，这个考试成绩能否有效反映出同学们学得好不好呢？
> 
> 答案是否定的，可能有的同学只会做这10道题却能得高分。

回到我们的问题上来，我们希望得到泛化性能强的模型，好比是希望同学们对课程学得很好、获得了对所学知识“举一反三”的能力；训练样本相当于给同学们练习的习题，测试过程则相当于考试。显然，**若测试样本被用作训练了，则得到的将是过于“乐观”的估计结果。**

可是，我们只有一个包含m个样例的数据集![20200222114223610.png][]

既要训练，又要测试，怎样才能做到呢？

*  答案是:**通过对D进行适当的处理，从中产生出训练集S和测试集T。（这个也是我们前面一直在做的事情）。**

下面我们一起总结一下几种常见的做法：

*  留出法
 *  交叉验证法
 *  自助法

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

## 1 留出法 ##

![20200222114237179.png][]

大家在使用的过程中，**需注意的是，训练/测试集的划分要尽可能保持数据分布的一致性，避免因数据划分过程引入额外的偏差而对最终结果产生影响**，例如在分类任务中至少要保持样本的类别比例相似。

如果从采样( sampling)的角度来看待数据集的划分过程，则保留类别比例的采样方式通常称为**“分层采样”( stratified sampling)。**

> 例如通过对D进行分层样而获得含70%样本的训练集S和含30%样本的测试集T，
> 
> 若D包含500个正例、500个反例，则分层采样得到的S应包含350个正例、350个反例，而T则包含150个正例和150个反例；
> 
> 若S、T中样本类别比例差别很大，则误差估计将由于训练/测试数据分布的差异而产生偏差。

另一个需注意的问题是，即便在给定训练测试集的样本比例后，仍存在多种划分方式对初始数据集D进行分割。

例如在上面的例子中，可以把D中的样本排序，然后把前350个正例放到训练集中，也可以把最后350个正例放到训练集中，这些不同的划分将导致不同的训练/测试集，相应的，模型评估的结果也会有差别。

因此，单次使用留出法得到的估计结果往往不够稳定可靠，**在使用留出法时，一般要采用若干次随机划分、重复进行实验评估后取平均值作为留出法的评估结果。**

> 例如进行100次随机划分，每次产生一个训练/测试集用于实验评估，100次后就得到100个结果，而留出法返回的则是这100个结果的平均。

此外，我们希望评估的是用D训练出的模型的性能，但留出法需划分训练/测试集，这就会导致一个窘境:

*  若令训练集S包含绝大多数样本，则训练出的模型可能更接近于用D训练出的模型，但由于T比较小，评估结果可能不够稳定准确；
 *  若令测试集T多包含一些样本，则训练集S与D差别更大了，被评估的模型与用D训练出的模型相比可能有较大差别，从而降低了评估结果的保真性( fidelity)。

这个问题没有完美的解决方案，常见做法是将大约2/3~4/5的样本用于训练，剩余样本用于测试。

使用Python实现留出法：

from sklearn.model_selection import train_test_split
    #使用train_test_split划分训练集和测试集
    train_X , test_X, train_Y ,test_Y = train_test_split(
            X, Y, test_size=0.2,random_state=0)

在留出法中，有一个特例，叫：**留一法( Leave-One-Out，简称LOO）**，即每次抽取一个样本做为测试集。

显然，留一法不受随机样本划分方式的影响，因为m个样本只有唯一的方式划分为m个子集一每个子集包含个样本；

使用Python实现留一法：

from sklearn.model_selection import LeaveOneOut
    
    data = [1, 2, 3, 4]
    loo = LeaveOneOut()
    for train, test in loo.split(data):
        print("%s %s" % (train, test))
    '''结果
    [1 2 3] [0]
    [0 2 3] [1]
    [0 1 3] [2]
    [0 1 2] [3]
    '''

留一法优缺点：

优点：

*  留一法使用的训练集与初始数据集相比只少了一个样本，这就使得在绝大多数情况下，留一法中被实际评估的模型与期望评估的用D训练出的模型很相似。因此，**留一法的评估结果往往被认为比较准确**。

缺点：

*  留一法也有其缺陷:在数据集比较大时，训练m个模型的计算开销可能是难以忍受的(例如数据集包含1百万个样本，则需训练1百万个模型，而这还是在未考虑算法调参的情况下。

## 2 交叉验证法 ##

![20200222114306324.png][]

然后，每次用k-1个子集的并集作为训练集，余下的那个子集作为测试集；这样就可获得k组训练/测试集，从而可进行k次训练和测试，最终返回的是这k个测试结果的均值。

显然，交叉验证法评估结果的稳定性和保真性在很大程度上取决于k的取值，为强调这一点，通常把交叉验证法称为“k折交叉验证”(k- fold cross validation)。k最常用的取值是10，此时称为10折交叉验证；其他常用的k值有5、20等。下图给出了10折交叉验证的示意图。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1][]

**与留出法相似，将数据集D划分为k个子集同样存在多种划分方式。**为减小因样本划分不同而引入的差别，k折交叉验证通常要随机使用不同的划分重复p次，最终的评估结果是这p次k折交叉验证结果的均值，例如常见的有 “10次10折交叉验证”。

交叉验证实现方法，除了咱们前面讲的GridSearchCV之外，还有KFold, StratifiedKFold

### KFold和StratifiedKFold ###

from sklearn.model_selection import KFold,StratifiedKFold

*  用法：
    
     *  将训练/测试数据集划分n\_splits个互斥子集，每次用其中一个子集当作验证集，剩下的n\_splits-1个作为训练集，进行n\_splits次训练和测试，得到n\_splits个结果
     *  StratifiedKFold的用法和KFold的区别是：SKFold是分层采样，确保训练集，测试集中，各类别样本的比例是和原始数据集中的一致。
 *  注意点：
    
     *  对于不能均等分数据集，其前n\_samples % n\_splits子集拥有n\_samples // n\_splits + 1个样本，其余子集都只有n\_samples // n\_splits样本
 *  参数说明：
    
     *  n\_splits：表示划分几等份
     *  shuffle：在每次划分时，是否进行洗牌
        
         *  ①若为Falses时，其效果等同于random\_state等于整数，每次划分的结果相同
         *  ②若为True时，每次划分的结果都不一样，表示经过洗牌，随机取样的
 *  属性：
    
     *  ①split(X, y=None, groups=None)：将数据集划分成训练集和测试集，返回索引生成器

import numpy as np
    from sklearn.model_selection import KFold,StratifiedKFold
    
    X = np.array([
        [1,2,3,4],
        [11,12,13,14],
        [21,22,23,24],
        [31,32,33,34],
        [41,42,43,44],
        [51,52,53,54],
        [61,62,63,64],
        [71,72,73,74]
    ])
    
    y = np.array([1,1,0,0,1,1,0,0])
    
    folder = KFold(n_splits = 4, random_state=0, shuffle = False)
    sfolder = StratifiedKFold(n_splits = 4, random_state = 0, shuffle = False)
    
    for train, test in folder.split(X, y):
        print('train:%s | test:%s' %(train, test))
        print("")
    
    for train, test in sfolder.split(X, y):
        print('train:%s | test:%s'%(train, test))
        print("")

结果：

可以看出，sfold进行4折计算时候，是平衡了测试集中，样本正负的分布的；但是fold却没有。

## 3 自助法 ##

我们希望评估的是用D训练出的模型。但在留出法和交叉验证法中，由于保留了一部分样本用于测试，因此**实际评估的模型所使用的训练集比D小，**这必然会引入一些因训练样本规模不同而导致的估计偏差。留一法受训练样本规模变化的影响较小，但计算复杂度又太高了。

有没有什么办法可以减少训练样本规模不同造成的影响，同时还能比较高效地进行实验估计呢？

“自助法”( bootstrapping)是一个比较好的解决方案，它**直接以自助采样法( bootstrap sampling)为基础**。给定包含m个样本的数据集D，我们对它进行采样产生数据集D:

*  每次随机从D中挑选一个样本，将其拷贝放入D，然后再将该样本放回初始数据集D中，使得该样本在下次采样时仍有可能被到；
 *  这个过程重复执行m次后，我们就得到了包含m个样本的数据集D′，这就是自助采样的结果。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2][]

即通过自助采样，初始数据集D中约有36.8%的样本未出现在采样数据集D′中。

于是我们可将D′用作训练集，D\\D′用作测试集；这样，实际评估的模型与期望评估的模型都使用m个训练样本，而我们仍有数据总量约1/3的、没在训练集中出现的样本用于测试。

这样的测试结果，亦称**“包外估计”(out- of-bagestimate）**

自助法优缺点：

*  优点：
    
     *  自助法在数据集较小、难以有效划分训练/测试集时很有用；
     *  此外，自助法能从初始数据集中产生多个不同的训练集，这对集成学习等方法有很大的好处。
 *  缺点：
    
     *  自助法产生的数据集改变了初始数据集的分布，这会引入估计偏差。因此，在初始数据量足够时；留出法和交叉验证法更常用一些。

## 4 总结 ##

**综上所述：**

*  当我们数据量足够时，选择留出法简单省时，在牺牲很小的准确度的情况下，换取计算的简便；
 *  当我们的数据量较小时，我们应该选择交叉验证法，因为此时划分样本集将会使训练数据过少；
 *  当我们的数据量特别少的时候，我们可以考虑留一法。

[20191009191333910.png]: https://img-blog.csdnimg.cn/20191009191333910.png
[Link 1]: http://www.rimengshe.com/
[AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]: https://blog.csdn.net/zimiao552147572/article/details/88867161
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200222114131857.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[20200222114141284.png]: https://img-blog.csdnimg.cn/20200222114141284.png
[20200222114223610.png]: https://img-blog.csdnimg.cn/20200222114223610.png
[20200222114237179.png]: https://img-blog.csdnimg.cn/20200222114237179.png
[20200222114306324.png]: https://img-blog.csdnimg.cn/20200222114306324.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200222114320614.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200222114349588.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg==,size_16,color_FFFFFF,t_70