转：『Sklearn』数据划分方法及python代码

最新推荐文章于 2024-07-08 04:42:33 发布
最新推荐文章于 2024-07-08 04:42:33 发布
阅读量1.3k 收藏 5
点赞数 1
分类专栏： PYTHON_机器学习
本文详细介绍了多种交叉验证方法，包括K折交叉验证、留一法、随机划分法等，并提供了每种方法的代码实现示例。

原理介绍

K折交叉验证：

KFold，GroupKFold，StratifiedKFold，

留一法：

LeaveOneGroupOut，LeavePGroupsOut，LeaveOneOut，LeavePOut，

随机划分法：

ShuffleSplit，GroupShuffleSplit，StratifiedShuffleSplit，

 

 

代码实现

流程：

实例化分类器 -> 迭代器迭代组[.split()]

KFold(n_splits=2)

1
2
3
4
5
6
7
8
9
10
11
12
#KFold<br>import numpy as np
from sklearn.model_selection import KFold
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
kf=KFold(n_splits=2)    # 定义分成几个组
# kf.get_n_splits(X)    # 查询分成几个组
print(kf)
for train_index,test_index in kf.split(X):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)

 GroupKFold(n_splits=2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# GroupKFold，不是很懂这个划分方法
import numpy as np
from sklearn.model_selection import GroupKFold
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
groups=np.array([1,2,3,4,5,6])
group_kfold=GroupKFold(n_splits=2)
group_kfold.get_n_splits(X,y,groups)
print(group_kfold)
for train_index,test_index in group_kfold.split(X,y,groups):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
 
#GroupKFold(n_splits=2)
#Train Index: [0 2 4] ,Test Index: [1 3 5]
#Train Index: [1 3 5] ,Test Index: [0 2 4]

  StratifiedKFold(n_splits=3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# stratifiedKFold：保证训练集中每一类的比例是相同的（尽量）
import numpy as np
from sklearn.model_selection import StratifiedKFold
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,1,1,2,2,2])
skf=StratifiedKFold(n_splits=3)
skf.get_n_splits(X,y)
print(skf)
for train_index,test_index in skf.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
 
#StratifiedKFold(n_splits=3, random_state=None, shuffle=False)
#Train Index: [1 2 4 5] ,Test Index: [0 3]
#Train Index: [0 2 3 5] ,Test Index: [1 4]

 LeaveOneOut()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# leaveOneOut：测试集就留下一个
import numpy as np
from sklearn.model_selection import LeaveOneOut
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
loo=LeaveOneOut()
loo.get_n_splits(X)
print(loo)
for train_index,test_index in loo.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
#LeaveOneOut()
#Train Index: [1 2 3 4 5] ,Test Index: [0]
#Train Index: [0 2 3 4 5] ,Test Index: [1]
#Train Index: [0 1 3 4 5] ,Test Index: [2]
#Train Index: [0 1 2 4 5] ,Test Index: [3]
#Train Index: [0 1 2 3 5] ,Test Index: [4]
#Train Index: [0 1 2 3 4] ,Test Index: [5]

LeavePOut(p=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
27
28
29
30
31
32
33
34
35
LeavePOut：测试集留下P个
import numpy as np
from sklearn.model_selection import LeavePOut
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
lpo=LeavePOut(p=3)
lpo.get_n_splits(X)
print(lpo)
for train_index,test_index in lpo.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
 
#LeavePOut(p=3)
#Train Index: [3 4 5] ,Test Index: [0 1 2]
#Train Index: [2 4 5] ,Test Index: [0 1 3]
#Train Index: [2 3 5] ,Test Index: [0 1 4]
#Train Index: [2 3 4] ,Test Index: [0 1 5]
#Train Index: [1 4 5] ,Test Index: [0 2 3]
#Train Index: [1 3 5] ,Test Index: [0 2 4]
#Train Index: [1 3 4] ,Test Index: [0 2 5]
#Train Index: [1 2 5] ,Test Index: [0 3 4]
#Train Index: [1 2 4] ,Test Index: [0 3 5]
#Train Index: [1 2 3] ,Test Index: [0 4 5]
#Train Index: [0 4 5] ,Test Index: [1 2 3]
#Train Index: [0 3 5] ,Test Index: [1 2 4]
#Train Index: [0 3 4] ,Test Index: [1 2 5]
#Train Index: [0 2 5] ,Test Index: [1 3 4]
#Train Index: [0 2 4] ,Test Index: [1 3 5]
#Train Index: [0 2 3] ,Test Index: [1 4 5]
#Train Index: [0 1 5] ,Test Index: [2 3 4]
#Train Index: [0 1 4] ,Test Index: [2 3 5]
#Train Index: [0 1 3] ,Test Index: [2 4 5]
#Train Index: [0 1 2] ,Test Index: [3 4 5]

 ShuffleSplit(n_splits=3,test_size=.25,random_state=0)

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
#ShuffleSplit 把数据集打乱顺序，然后划分测试集和训练集，训练集额和测试集的比例随机选定，训练集和测试集的比例的和可以小于1
  
import numpy as np
from sklearn.model_selection import ShuffleSplit
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
rs=ShuffleSplit(n_splits=3,test_size=.25,random_state=0)
rs.get_n_splits(X)
print(rs)
for train_index,test_index in rs.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
print("==============================")
rs=ShuffleSplit(n_splits=3,train_size=.5,test_size=.25,random_state=0)
rs.get_n_splits(X)
print(rs)
for train_index,test_index in rs.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
 
#ShuffleSplit(n_splits=3, random_state=0, test_size=0.25, train_size=None)
#Train Index: [1 3 0 4] ,Test Index: [5 2]
#Train Index: [4 0 2 5] ,Test Index: [1 3]
#Train Index: [1 2 4 0] ,Test Index: [3 5]
#==============================
#ShuffleSplit(n_splits=3, random_state=0, test_size=0.25, train_size=0.5)
#Train Index: [1 3 0] ,Test Index: [5 2]
#Train Index: [4 0 2] ,Test Index: [1 3]
#Train Index: [1 2 4] ,Test Index: [3 5]

 StratifiedShuffleSplit(n_splits=3,test_size=.5,random_state=0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# StratifiedShuffleSplitShuffleSplit 把数据集打乱顺序，然后划分测试集和训练集，
# 训练集额和测试集的比例随机选定，训练集和测试集的比例的和可以小于1,但是还要保证训练集中各类所占的比例是一样的
 
import numpy as np
from sklearn.model_selection import StratifiedShuffleSplit
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,1,2,1,2])
sss=StratifiedShuffleSplit(n_splits=3,test_size=.5,random_state=0)
sss.get_n_splits(X,y)
print(sss)
for train_index,test_index in sss.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
 
#StratifiedShuffleSplit(n_splits=3, random_state=0, test_size=0.5,train_size=None)
#Train Index: [5 4 1] ,Test Index: [3 2 0]
#Train Index: [5 2 3] ,Test Index: [0 4 1]
#Train Index: [5 0 4] ,Test Index: [3 1 2]
【Python机器学习】零基础掌握GroupShuffleSplit交叉验证
Mr数据杨
11-03 270
通过本文的深入解析对这一强大的数据划分工具有了全面而深刻的认识。通过结合足球运动员的实际案例展示了如何利用按组结构准确划分数据集，确保训练集和测试集中的数据分布更加均衡和公正。代码演示和数据可视化进一步加深了对该算法运作方式的理解，使得即使是对机器学习不熟悉的小伙伴也能够轻松把握其核心要点。优点总结，在处理具有组结构的数据时展现出了显著的优势，能够有效避免数据泄漏，提升模型评估的准确性。优点描述避免数据泄漏确保同一组内的数据不会同时出现在训练集和测试集中提升模型评估准确性。
【Python机器学习】零基础掌握GroupKFold交叉验证
Mr数据杨
11-03 324
本次介绍的GroupKFold算法是一种交叉验证方法，特别适用于处理组内数据相关性较强的情况。通过将数据划分为若干组，并确保同一组的数据不会同时出现在训练集和测试集中，该方法提高了模型评估的准确性和可靠性。优点总结，GroupKFold在处理组内关联性强的数据时表现出色，能够避免信息泄露，提高模型评估的准确性。此外，它在实际应用中相对易于实现，配合sklearn库，可以快速进行模型的交叉验证。优点描述避免信息泄露。
Scikit-learn文本分类
09-02
包含4部分数据下载，提取特征，Pipline 训练模型，GridSearchCV 寻找最优参数。用到的算法，NB, KNN,SVM,
【Sklearn】数据划分方法
小苏打的学习博客
06-28 1307
原理介绍 1. K折交叉验证： KFold，GroupKFold，StratifiedKFold 2. 留一法： LeaveOneGroupOut，LeavePGroupsOut，LeaveOneOut，LeavePOut 3.随机划分法： ShuffleSplit，GroupShuffleSplit，StratifiedShuffleSplit 代码实现 流程： 实例化分类器 -> ...
sklearn ShuffleSplit.split()使用说明，内有大坑（结合for循环清零问题）
weixin_43843003的博客
09-13 4077
sklearn.model_selection.ShuffleSplit类用于将样本集合随机“打散”后划分为训练集、测试集(可理解为验证集，下同)，类申明如下： 官方文档使用说明 官方文档链接 class sklearn.model_selection.ShuffleSplit(n_splits=10, test_size=None, train_size=None, random_state=N...
Scikit-learn的K-fold交叉验证类ShuffleSplit、GroupShuffleSplit用法介绍
热门推荐
YQ的博客
06-26 2万+
当样本数据量比较小时，K-fold交叉验证是训练、评价模型时的常用方法，本文介绍Scikit-learn的可用于K-fold交叉验证的集合划分类ShuffleSplit、GroupShuffleSplit的用法。
聚类精度的尺标：SKlearn中的数据聚类性能评估方法
最新发布
2401_85763803的博客
07-08 768
聚类分析是无监督学习中的核心任务之一，其目的在于将数据集中的样本划分为若干个簇，使得同一簇内的样本相似度高，而不同簇间的样本相似度低。Scikit-learn（简称sklearn），作为Python中一个功能丰富的机器学习库，提供了多种方法来评估聚类的性能。本文将详细介绍sklearn中用于数据聚类性能评估的方法，并提供实际的代码示例。通过本文，我们了解到了这些指标的计算方法和应用场景，并提供了实际的代码示例。随着数据量的不断增长和聚类分析需求的提高，聚类性能评估将在数据科学领域发挥越来越重要的作用。
数据挖掘 | [有监督学习——分类] 决策树基本知识及python代码实现——利用sklearn
12-21
熵是度量数据纯度的一个指标，信息增益越大，意味着选择该属性划分数据后，各个子集的纯度提高得越多。算法会选取信息增益最大的属性作为当前节点的分裂依据。 在Python中，我们可以使用`sklearn`库中的`tree`模块...
sklearn+python:线性回归案例
09-17
首先，我们需要导入必要的库，包括`load_boston`来获取波士顿房价数据集，`train_test_split`来进行数据划分，以及`LinearRegression`来构建线性回归模型。波士顿房价数据集包含了13个特征，如犯罪率（CRIM）、住宅...
在Sklearn中使用SVC运行RFE的python代码
05-01
下面是一个使用SVC作为基础分类器的RFE示例代码： ```python from sklearn import datasets from sklearn.feature_selection import RFE from sklearn.svm import SVC from sklearn.model_selection import train_...
对sklearn的使用之数据集的拆分与训练详解(python3.6)
09-19
`sklearn`库是Python中最常用的机器学习库之一，提供了丰富的数据处理和模型训练功能。本文将深入讲解如何在Python 3.6环境下利用`sklearn`进行数据集的拆分与训练。 首先，我们导入所需的库，包括`datasets`、`...
Scikit-learn的ShuffleSplit与GroupShuffleSplit
gaocui883的博客
12-21 788
官方文档说明： class GroupShuffleSplit(ShuffleSplit): '''Shuffle-Group(s)-Out cross-validation iterator Provides randomized train/test indices to split data according to a third-party provided group. This group information can be used to encode a
【计算机视觉 | 目标检测】术语理解5：Split Shuffle Block、Group Shuffle Block 和复杂非结构化室内场景
wzk4869的博客
05-27 1958
【计算机视觉 | 目标检测】术语理解5：Split Shuffle Block、Group Shuffle Block 和复杂非结构化室内场景
K折交叉验证大集合（KFold 、Stratified k-fold、Group k-fold、StratifiedGroupKFold）
向上生长的程序媛的博客
11-01 2022
交叉验证是区分训练集合验证集的一种方法，不同的交叉验证方法就是根据不同的规则来指定训练集合验证集，今天就来深扒一下每个多折交叉验证方法（KFold 、Stratified k-fold、Group k-fold、StratifiedGroupKFold）的详细内容和他们之间的区别吧！
Sklearn中不同的数据抽样验证方式
weixin_43646592的博客
07-21 2039
普通交叉随机抽样验证：train_test_split()： from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2) from sklearn.model_selection import (TimeSeriesSplit, KFold, ShuffleSplit,
sklearn的模型选择和评估之交叉验证
koukehui0292的博客
10-15 1976
import numpy as np 交叉验证：评估学习器的表现 划分数据为训练集和测试集 X, y = np.arange(10).reshape((5, 2)), range(5) print(X) print(y) [[0 1] [2 3] [4 5] [6 7] [8 9]] range(0, 5) from sklearn.model_selection import tr...
python机器学习库sklearn——交叉验证（K折、留一、留p、随机）
Christina
07-21 1485
学习预测函数的参数，并在相同数据集上进行测试是一种错误的做法: 一个仅给出测试用例标签的模型将会获得极高的分数，但对于尚未出现过的数据它则无法预测出任何有用的信息。例如，如果数据是从不同的 subjects 获得的，每个 subject 有多个样本，并且如果模型足够灵活以高度人物指定的特征中学习，则可能无法推广到新的 subject。StratifiedShuffleSplit 是 ShuffleSplit 的一个变种，会返回直接的划分，比如： 创建一个划分，但是划分中每个类的比例和完整数据集中的相同。
K折交叉验证的使用之KFold和split函数
weixin_42621901的博客
08-03 1万+
使用方法： # 导入方式 from sklearn.model_selection import KFold KFold(n_split, random_state, shuffle) 参数： n_split：需要划分多少折数 shuffle：是否进行数据打乱 random_state：随机数 skf = KFold(n_splits=10, random_state=233, shuffle=True) KFold()方法中的split()： split(a,b)：方法会根据折数对a和b进行划分。
Python聚类分析实践：使用SKLearn实现数据分类
该文件将包含实际的Python代码，用于实现聚类分析的各个步骤，包括数据读取、预处理、模型应用、结果评估和可视化。 另一个文件cluster.txt可能包含一些与聚类相关的文本信息，如算法描述、参数设置指导或者聚类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值