交叉验证

sklearn中的交叉验证（Cross-Validation）

sklearn是利用python进行机器学习中一个非常全面和好用的第三方库，用过的都说好。今天主要记录一下sklearn中关于交叉验证的各种用法，主要是对sklearn官方文档 Cross-validation: evaluating estimator performance进行讲解，英文水平好的建议读官方文档，里面的知识点很详细。

先导入需要的库及数据集

In [1]: import numpy as npIn [2]: from sklearn.model_selection import train_test_splitIn [3]: from sklearn.datasets import load_irisIn [4]: from sklearn import svmIn [5]: iris = load_iris()In [6]: iris.data.shape, iris.target.shape
Out[6]: ((150, 4), (150,))

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

1.train_test_split

对数据集进行快速打乱（分为训练集和测试集）

这里相当于对数据集进行了shuffle后按照给定的test_size 进行数据集划分。

In [7]: X_train, X_test, y_train, y_test = train_test_split(...:         iris.data, iris.target, test_size=.4, random_state=0)#这里是按照6:4对训练集测试集进行划分In [8]: X_train.shape, y_train.shape
Out[8]: ((90, 4), (90,))In [9]: X_test.shape, y_test.shape
Out[9]: ((60, 4), (60,))In [10]: iris.data[:5]
Out[10]: 
array([[ 5.1,  3.5,  1.4,  0.2],[ 4.9,  3. ,  1.4,  0.2],[ 4.7,  3.2,  1.3,  0.2],[ 4.6,  3.1,  1.5,  0.2],[ 5. ,  3.6,  1.4,  0.2]])In [11]: X_train[:5]
Out[11]: 
array([[ 6. ,  3.4,  4.5,  1.6],[ 4.8,  3.1,  1.6,  0.2],[ 5.8,  2.7,  5.1,  1.9],[ 5.6,  2.7,  4.2,  1.3],[ 5.6,  2.9,  3.6,  1.3]])In [12]: clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)In [13]: clf.score(X_test, y_test)
Out[13]: 0.96666666666666667
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

2.cross_val_score

对数据集进行指定次数的交叉验证并为每次验证效果评测

其中，score 默认是以 scoring=’f1_macro’进行评测的，余外针对分类或回归还有： 
这里写图片描述
这需要from　sklearn import metrics ,通过在cross_val_score 指定参数来设定评测标准； 
当cv 指定为int 类型时，默认使用KFold 或StratifiedKFold 进行数据集打乱，下面会对KFold和StratifiedKFold 进行介绍。


In [15]: from sklearn.model_selection import cross_val_scoreIn [16]: clf = svm.SVC(kernel='linear', C=1)In [17]: scores = cross_val_score(clf, iris.data, iris.target, cv=5)In [18]: scores
Out[18]: array([ 0.96666667,  1.        ,  0.96666667,  0.96666667,  1.        ])In [19]: scores.mean()
Out[19]: 0.98000000000000009
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

除使用默认交叉验证方式外，可以对交叉验证方式进行指定，如验证次数，训练集测试集划分比例等

In [20]: from sklearn.model_selection import ShuffleSplitIn [21]: n_samples = iris.data.shape[0]In [22]: cv = ShuffleSplit(n_splits=3, test_size=.3, random_state=0)In [23]: cross_val_score(clf, iris.data, iris.target, cv=cv)
Out[23]: array([ 0.97777778,  0.97777778,  1.        ])

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

在cross_val_score 中同样可使用pipeline 进行流水线操作

In [24]: from sklearn import preprocessingIn [25]: from sklearn.pipeline import make_pipelineIn [26]: clf = make_pipeline(preprocessing.StandardScaler(), svm.SVC(C=1))In [27]: cross_val_score(clf, iris.data, iris.target, cv=cv)
Out[27]: array([ 0.97777778,  0.93333333,  0.95555556])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

3.cross_val_predict

cross_val_predict 与cross_val_score 很相像，不过不同于返回的是评测效果，cross_val_predict 返回的是estimator 的分类结果（或回归值），这个对于后期模型的改善很重要，可以通过该预测输出对比实际目标值，准确定位到预测出错的地方，为我们参数优化及问题排查十分的重要。

In [28]: from sklearn.model_selection import cross_val_predictIn [29]: from sklearn import metricsIn [30]: predicted = cross_val_predict(clf, iris.data, iris.target, cv=10)In [31]: predicted
Out[31]: 
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2,2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2,2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])In [32]: metrics.accuracy_score(iris.target, predicted)
Out[32]: 0.96666666666666667
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

4.KFold

K折交叉验证，这是将数据集分成K份的官方给定方案，所谓K折就是将数据集通过K次分割，使得所有数据既在训练集出现过，又在测试集出现过，当然，每次分割中不会有重叠。相当于无放回抽样。

In [33]: from sklearn.model_selection import KFoldIn [34]: X = ['a','b','c','d']In [35]: kf = KFold(n_splits=2)In [36]: for train, test in kf.split(X):...:     print train, test...:     print np.array(X)[train], np.array(X)[test]...:     print '\n'...:     
[2 3] [0 1]
['c' 'd'] ['a' 'b'][0 1] [2 3]
['a' 'b'] ['c' 'd']

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

5.LeaveOneOut

LeaveOneOut 其实就是KFold 的一个特例，因为使用次数比较多，因此独立的定义出来，完全可以通过KFold 实现。


In [37]: from sklearn.model_selection import LeaveOneOutIn [38]: X = [1,2,3,4]In [39]: loo = LeaveOneOut()In [41]: for train, test in loo.split(X):...:     print train, test...:     
[1 2 3] [0]
[0 2 3] [1]
[0 1 3] [2]
[0 1 2] [3]#使用KFold实现LeaveOneOtut
In [42]: kf = KFold(n_splits=len(X))In [43]: for train, test in kf.split(X):...:     print train, test...:     
[1 2 3] [0]
[0 2 3] [1]
[0 1 3] [2]
[0 1 2] [3]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

6.LeavePOut

这个也是KFold 的一个特例，用KFold 实现起来稍麻烦些，跟LeaveOneOut 也很像。


In [44]: from sklearn.model_selection import LeavePOutIn [45]: X = np.ones(4)In [46]: lpo = LeavePOut(p=2)In [47]: for train, test in lpo.split(X):...:     print train, test...:     
[2 3] [0 1]
[1 3] [0 2]
[1 2] [0 3]
[0 3] [1 2]
[0 2] [1 3]
[0 1] [2 3]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

7.ShuffleSplit

ShuffleSplit 咋一看用法跟LeavePOut 很像，其实两者完全不一样，LeavePOut 是使得数据集经过数次分割后，所有的测试集出现的元素的集合即是完整的数据集，即无放回的抽样，而ShuffleSplit 则是有放回的抽样，只能说经过一个足够大的抽样次数后，保证测试集出现了完成的数据集的倍数。

In [48]: from sklearn.model_selection import ShuffleSplitIn [49]: X = np.arange(5)In [50]: ss = ShuffleSplit(n_splits=3, test_size=.25, random_state=0)In [51]: for train_index, test_index in ss.split(X):...:     print train_index, test_index...:     
[1 3 4] [2 0]
[1 4 3] [0 2]
[4 0 2] [1 3]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

8.StratifiedKFold

这个就比较好玩了，通过指定分组，对测试集进行无放回抽样。

In [52]: from sklearn.model_selection import StratifiedKFoldIn [53]: X = np.ones(10)In [54]: y = [0,0,0,0,1,1,1,1,1,1]In [55]: skf = StratifiedKFold(n_splits=3)In [56]: for train, test in skf.split(X,y):...:     print train, test...:     
[2 3 6 7 8 9] [0 1 4 5]
[0 1 3 4 5 8 9] [2 6 7]
[0 1 2 4 5 6 7] [3 8 9]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

9.GroupKFold

这个跟StratifiedKFold 比较像，不过测试集是按照一定分组进行打乱的，即先分堆，然后把这些堆打乱，每个堆里的顺序还是固定不变的。

In [57]: from sklearn.model_selection import GroupKFoldIn [58]: X = [.1, .2, 2.2, 2.4, 2.3, 4.55, 5.8, 8.8, 9, 10]In [59]: y = ['a','b','b','b','c','c','c','d','d','d']In [60]: groups = [1,1,1,2,2,2,3,3,3,3]In [61]: gkf = GroupKFold(n_splits=3)In [62]: for train, test in gkf.split(X,y,groups=groups):...:     print train, test...:     
[0 1 2 3 4 5] [6 7 8 9]
[0 1 2 6 7 8 9] [3 4 5]
[3 4 5 6 7 8 9] [0 1 2]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

10.LeaveOneGroupOut

这个是在GroupKFold 上的基础上混乱度又减小了，按照给定的分组方式将测试集分割下来。

In [63]: from sklearn.model_selection import LeaveOneGroupOutIn [64]: X = [1, 5, 10, 50, 60, 70, 80]In [65]: y = [0, 1, 1, 2, 2, 2, 2]In [66]: groups = [1, 1, 2, 2, 3, 3, 3]In [67]: logo = LeaveOneGroupOut()In [68]: for train, test in logo.split(X, y, groups=groups):...:     print train, test...:     
[2 3 4 5 6] [0 1]
[0 1 4 5 6] [2 3]
[0 1 2 3] [4 5 6]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

11.LeavePGroupsOut

这个没啥可说的，跟上面那个一样，只是一个是单组，一个是多组

from sklearn.model_selection import LeavePGroupsOutX = np.arange(6)y = [1, 1, 1, 2, 2, 2]groups = [1, 1, 2, 2, 3, 3]lpgo = LeavePGroupsOut(n_groups=2)for train, test in lpgo.split(X, y, groups=groups):print train, test[4 5] [0 1 2 3]
[2 3] [0 1 4 5]
[0 1] [2 3 4 5]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

12.GroupShuffleSplit

这个是有放回抽样

In [75]: from sklearn.model_selection import GroupShuffleSplitIn [76]: X = [.1, .2, 2.2, 2.4, 2.3, 4.55, 5.8, .001]In [77]: y = ['a', 'b','b', 'b', 'c','c', 'c', 'a']In [78]: groups = [1,1,2,2,3,3,4,4]In [79]: gss = GroupShuffleSplit(n_splits=4, test_size=.5, random_state=0)In [80]: for train, test in gss.split(X, y, groups=groups):...:     print train, test...:     
[0 1 2 3] [4 5 6 7]
[2 3 6 7] [0 1 4 5]
[2 3 4 5] [0 1 6 7]
[4 5 6 7] [0 1 2 3]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

13.TimeSeriesSplit

针对时间序列的处理，防止未来数据的使用，分割时是将数据进行从前到后切割（这个说法其实不太恰当，因为切割是延续性的。。）

In [81]: from sklearn.model_selection import TimeSeriesSplitIn [82]: X = np.array([[1,2],[3,4],[1,2],[3,4],[1,2],[3,4]])In [83]: tscv = TimeSeriesSplit(n_splits=3)In [84]: for train, test in tscv.split(X):...:     print train, test...:     
[0 1 2] [3]
[0 1 2 3] [4]
[0 1 2 3 4] [5]

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/508940.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

机器学习名词解释

机器学习名词解释

1. 损失函数 损失函数是用来估量你模型的预测值f(x)与真实值Y的不一致程度，它是一个非负实值函数,通常使用L(Y, f(x))来表示，损失函数越小，模型的鲁棒性就越好。损失函数是经验风险函数的核心部分，也是结构风险函数重要组成部分。…
阅读更多...
【转载保存】推荐ApacheCN开源的一个机器学习路线图

【转载保存】推荐ApacheCN开源的一个机器学习路线图

转载：https://mp.weixin.qq.com/s/EMWFFPsaKaGc8FO1g-htzg 推荐ApacheCN开源的一个机器学习路线图 原创： 机器学习初学者 机器学习初学者 今天 推荐一个ApacheCN开源的一个机器学习路线图： https://github.com/apachecn/AiLearning 注意…
阅读更多...
CNN(Convolutional Neural Network) 的基础

CNN(Convolutional Neural Network) 的基础

卷积神经网络（Convolutional Neural Network，简称CNN），是一种前馈神经网络，人工神经元可以响应周围单元，可以进行大型图像处理。卷积神经网络包括卷积层和池化层。 卷积神经网络是受到生物思考方式启发的ML…
阅读更多...
语音识别学习日志 2019-7-14 语音识别基础知识准备2 {EM算法与混合高斯模型(Gaussian mixture model, GMM)}

语音识别学习日志 2019-7-14 语音识别基础知识准备2 {EM算法与混合高斯模型(Gaussian mixture model, GMM)}

https://blog.csdn.net/lin_limin/article/details/81048411会对GMM和EM做详细介绍 本文参考： http://www.ituring.com.cn/article/497545(GMM模型) https://blog.csdn.net/xmu_jupiter/article/details/50889023(GMM模型) http://www.cnblogs.com/wjy-lulu/p/7…
阅读更多...
【爬虫】爬取带有cookie才能获取网页内容的新闻网站

【爬虫】爬取带有cookie才能获取网页内容的新闻网站

工作任务： 今天老大让我跑取一个新闻网站：https://www.yidaiyilu.gov.cn/ 采坑记录： https协议，如果利用http协议去请求会报出如下信息： 错误：SSLHandshake错误就知道了，客户端与服务端进行连…
阅读更多...
语音识别学习日志 2019-7-14 语音识别基础知识准备3 {Kmean算法分析与HMM(Hidden Markov Model)模型}

语音识别学习日志 2019-7-14 语音识别基础知识准备3 {Kmean算法分析与HMM(Hidden Markov Model)模型}

Kmean算法 聚类算法 对于"监督学习"(supervised learning)，其训练样本是带有标记信息的，并且监督学习的目的是：对带有标记的数据集进行模型学习，从而便于对新的样本进行分类。而在“无监督学习”(unsupervised learni…
阅读更多...
语音识别学习日志 2019-7-15 语音识别基础知识准备4 {Baun-Welch算法}

语音识别学习日志 2019-7-15 语音识别基础知识准备4 {Baun-Welch算法}

HMM 前向算法(Forward Algorithm)详细解释参考: http://www.52nlp.cn/hmm-learn-best-practices-five-forward-algorithm-1 http://www.52nlp.cn/hmm-learn-best-practices-five-forward-algorithm-2 http://www.52nlp.cn/hmm-learn-best-practices-five-forward-algorithm-3…
阅读更多...
【转载保存】B+树索引原理以及应用案例

【转载保存】B+树索引原理以及应用案例

地址：https://www.jianshu.com/p/486a514b0ded 利用c/c实现基于b树小型关系型数据库：https://github.com/enpeizhao/duck_db 利用java实现的基于b树的数据库案例：https://github.com/liumengjun/BPlusTreeIndex 1.什么是索引？ …
阅读更多...
语音识别学习日志 2019-7-16 语音识别基础知识准备5 {决策树算法(ID3、 C4.5、 CART)}

语音识别学习日志 2019-7-16 语音识别基础知识准备5 {决策树算法(ID3、 C4.5、 CART)}

决策树算法(ID3、 C4.5、 CART) 决策树的定义 决策树学习采用的是自顶向下的递归方法，其基本思想是以信息熵为度量构造一颗熵值下降最快的树，到叶子节点处，熵值为0。其具有可读性、分类速度快的优点，是一种有监督学习。 决策树呈…
阅读更多...
语音识别学习日志 2019-7-17 语音识别基础知识准备6 {维特比算法(Viterbi Algorithm)}

语音识别学习日志 2019-7-17 语音识别基础知识准备6 {维特比算法(Viterbi Algorithm)}

HMM 维特比算法(Viterbi Algorithm)详细解释参考:http://www.52nlp.cn/hmm-learn-best-practices-six-viterbi-algorithm-1 http://www.52nlp.cn/hmm-learn-best-practices-six-viterbi-algorithm-2 http://www.52nlp.cn/hmm-learn-best-practices-six-viterbi-algorithm-3 …
阅读更多...
基于包围盒算法的三维点云数据压缩和曲面重建matlab仿真

基于包围盒算法的三维点云数据压缩和曲面重建matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 4.1 包围盒构建 4.2 点云压缩 4.3 曲面重建 5.算法完整程序工程 1.算法运行效果图预览 2.算法运行软件版本 matlab2022a 3.部分核心程序 ...........................................…
阅读更多...
【转载保存】修改IK分词器源码实现动态加载词典

【转载保存】修改IK分词器源码实现动态加载词典

链接：http://www.gongstring.com/portal/article/index/id/59.html 当前IKAnalyzer从发布最后一个版本后就一直没有再更新，使用过程中，经常遇到需要扩展词库以及动态更新字典表的问题，此处给出一种解决办法（注意&…
阅读更多...
【转载保存】索引文件锁LockFactory

【转载保存】索引文件锁LockFactory

索引文件锁LockFactory LockFactory在Lucene中用来对索引文件所在的目录进行加锁，使得同一时间总是只有一个IndexWriter对象可以更改索引文件，即保证单进程内(single in-process)多个不同IndexWriter对象互斥更改（多线程持有相同引用的IndexW…
阅读更多...
IndexOptions类说明

IndexOptions类说明

IndexOptions是在lucene-core-x.jar包下面，其作用是在新建索引时候选择索引属性。 IndexOptions是一个枚举类： 枚举变量说明： NONE不被索引DOCS_AND_FREQS文档和词频建立索引DOCS_AND_FREQS仅对文档和词频建立索引DOCS_AND_FREQS_AND_POSIT…
阅读更多...
【转载保存】lucene正则查询使用注意

【转载保存】lucene正则查询使用注意

今天要分享的是关于lucene中另外一种丰富的查询方式----正则查询，lucene内置了许多的查询API，以及更强大的自定义查询方式的QueryParse，大部分情况下我们使用内置的查询API，基本上就可以满足我们的需求了，但是如果你想…
阅读更多...
【转载保存】搜索引擎调研文档

【转载保存】搜索引擎调研文档

搜索引擎选型调研文档 Elasticsearch简介* Elasticsearch是一个实时的分布式搜索和分析引擎。它可以帮助你用前所未有的速度去处理大规模数据。 它可以用于全文搜索，结构化搜索以及分析，当然你也可以将这三者进行组合。 Elasticsearch是一个建立在全…
阅读更多...
lucene详细说明文档

lucene详细说明文档

以下部门功能在lucene5以上版本可能有的API所有改变 目录1.简介 2.了解索引操作 2.1倒排索引 2.2字段类型 2.3细分 2.4文件编号 2.5搜索索引 3.创建索引 4.基本索引操作 4.1核心索引类 4.2将数据添加到索引 5.文件和领域 5.1文件 5.2领域 5.3在Lucene中增强文档 1.简介 该索引是…
阅读更多...
分布式集群架构场景解决方案学习笔记

分布式集群架构场景解决方案学习笔记

课程学习 一致性哈希算法集群时钟同步问题分布式ID解决方案分布式任务调度问题session共享(一致性)问题 一致性哈希算法 一致性哈希算法在1997年由麻省理工学院的Karger等人在解决分布式Cache中提出的，设计目标是为了解决因特网中的热点(Hot spot)问题&#xff0c…
阅读更多...
分布式学习-总结

分布式学习-总结

文章目录分布式理论分布式系统定义以及面临的问题分布式系统定义分布式面临的问题通信异常网络分区三态节点故障分布式理论：一致性概念分布式一致性的提出强一致性弱一致性最终一致性分布式事务CAP定理什么是CAP理论？为什么只能3选2能不能解决3选2的问题…
阅读更多...
什么叫死锁？死锁案例？死锁必须满足哪些条件？如何定位死锁问题？有哪些解决死锁策略？哲学家问题？

什么叫死锁？死锁案例？死锁必须满足哪些条件？如何定位死锁问题？有哪些解决死锁策略？哲学家问题？

1.死锁是什么？ 死锁一定发生在并发环境中，死锁是一种状态，当两个(或者多个线程)相互持有对方所需要的资源，却又都不主动释放手中持有的资源，导致大家都获取不到自己想要的资源，所有相关的线程无法继续执行…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023