sklearn训练/测试数据集划分

最新推荐文章于 2023-07-03 16:03:15 发布
转载 最新推荐文章于 2023-07-03 16:03:15 发布 · 1k 阅读 · 2

本文深入解析了多种交叉验证方法，包括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

13

#KFold

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]

转自：https://www.cnblogs.com/hellcat/p/7045585.html 

使用sklearn将数据集分为训练集和测试集
修炼之路
03-07 6万+
在使用机器学习算法之前，通常我们需要先将数据集分为训练集和测试集。在分配训练集和测试集的时候，如果测试集的数据越小，对模型的泛化误差的估计将会越不准确。所以，在划分数据集的时候我们需要进行权衡。在实际应用中，基于整个数据集数据的大小，训练集数据和测试集数据的划分比例是6:4、7:3或8:2。对于庞大的数据可以使用9:1，甚至是99:1。我们可以直接使用sklearn提供的train_test_sp...
零基础入门金融风控之贷款违约预测—建模与调参
sosososoon的博客
09-24 1751
基本模型 逻辑回归 逻辑回归是一个假设样本服从伯努利分布 (f(x∣p)=px(1−p)n−xf(x|p) = p^x(1-p)^{n-x}f(x∣p)=px(1−p)n−x)，利用极大似然估计和梯度下降求解的二分类模型。 逻辑回归本质上是线性回归，只是在特征到结果的映射中加入了一个 sigmoid 函数，即先把特征线性求和，然后使用非线性的函数将连续值映射到 0 与 1 之间。   优点 训练速度较快，分类的时候，计算量仅仅只和特征的数目相关 简单易理解，模型的可解释性非常好，从特征的权重可
Sklearn中不同的数据抽样验证方式
weixin_43646592的博客
07-21 2095
普通交叉随机抽样验证：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,
Python中的KFold与StratifiedKFold
weixin_48697962的博客
07-25 1717
KFold与StratifiedKFold
sklearn的模型选择和评估之交叉验证
koukehui0292的博客
10-15 1990
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...
sklearn中测试及和训练集分离及选取
qq_22667507的博客
04-23 394
sklearn中的train_test_split： from sklearn.model_selection import train_test_split data_train,data_test,label_train,label_test = train_test_split(x,y,test_size=0.3,random_state=123) test = KNeighborsClassifier(n_neighbors=4) test.fit(data_train,label_train)
sklearn 标准化训练数据
一花一世界 一叶一菩提
05-02 807
参考网址：http://www.cnblogs.com/chaosimple/p/4153167.html
用pandas划分数据集实现训练集和测试集
09-16
在Python中，pandas库通常用于数据处理，而sklearn库则提供了划分训练集和测试集的功能。本文将详细介绍如何利用pandas和sklearn的model_selection模块来实现这一过程。 首先，我们引入pandas库读取数据，如在示例...
python 划分数据集为训练集和测试集的方法
09-19
训练集用于训练模型，而测试集则用来验证模型的泛化能力。Python中，我们经常使用`sklearn`库来处理这个问题。本文将详细介绍如何使用`sklearn`中的`train_test_split`函数以及自定义函数来划分数据集。 首先，我们...
sklearn数据集、数据集划分与k-近邻算法
weixin_44457930的博客
04-10 1011
sklearn数据集API 加载获取流行数据集： （1）datasets.load_() 获取小规模数据集，数据包含在datasets里 （2）datasets.fetch_(data_home=None) 获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录，默认是 ~/scikit_learn_data/ load和fetch返回的数据类型datasets.base.Bunch(字典格式) data：特征数据数组，是 [n_samples * n_feature
对sklearn的使用之数据集的拆分与训练详解(python3.6)
09-19
本文将深入讲解如何在Python 3.6环境下利用`sklearn`进行数据集的拆分与训练。 首先，我们导入所需的库，包括`datasets`、`model_selection`、`grid_search`、`metrics`和`svm`。`datasets`用于加载预定义的数据集...
python训练数据集_Python——sklearn提供的自带的数据集
weixin_39737757的博客
11-21 512
sklearn提供的自带的数据集sklearn 的数据集有好多个种自带的小数据集（packaged dataset）：sklearn.datasets.load_可在线下载的数据集（Downloaded Dataset）：sklearn.datasets.fetch_计算机生成的数据集（Generated Dataset）：sklearn.datasets.make_svmlight/libsvm...
python机器学习库sklearn——交叉验证（K折、留一、留p、随机）
weixin_43758551的博客
06-02 6487
https://blog.csdn.net/luanpeng825485697/article/details/79836262 学习预测函数的参数，并在相同数据集上进行测试是一种错误的做法: 一个仅给出测试用例标签的模型将会获得极高的分数，但对于尚未出现过的数据它则无法预测出任何有用的信息。 这种情况称为 overfitting（过拟合）. 为了避免这种情况，在进行（监督）机器学习实验时，通常取...
交叉验证——对数据集的划分
一颗胡萝卜的秘密基地
08-06 3329
写在前面： 为什么划分数据集? 以我们的比赛为例，赛方提供有标签的训练数据和无标签的测试数据，要求我们提交测试数据的预测标签值，如果我们不划分数据集，直接用所有的数据进行训练，最后直接对无标签的测试数据预测，我们很难预测我们模型的好坏。以我的理解来看，对于数据集划分形成的验证集，相当于是平时学习中的小考，而测试数据可以看成是期末考或者高考，我们想通过数据集的划分，在验证集上达到评估我们学习能力学习效果的作用，最后为高考或者期末考做准备。 “划分数据集”其实就等同于“交叉验证” 交叉验证的基本思想是在某
机器学习常用函数解析
anmin1992的专栏
08-29 981
机器学习常用函数解析 逻辑回归 from sklearn.preprocessing import StandardScaler 1. StandardScaler(copy=True, with_mean=True, with_std=True) 使用: scaler = StandardScaler(copy=True, with_mean=True, wit...
sklearn 中 ShuffleSplit 函数 的详细使用方法 （机器学习）
优快云 精品推荐
02-08 6204
ShuffleSplit函数的使用方法 1、原理 用于将样本集合随机“打散”后划分为训练集、测试集(可理解为验证集，下同) 类似于交叉验证 2、函数形式 ShuffleSplit(n_splits=10, test_size=’default’, train_size=None, random_state=None) 3、重要参数 n_splits: 划分数据集的份数，类似于KFlod的折数，默认为10份 test_size： 测试集所占总样本的比例，如test_size=0.2即将划分后的数据集中20%作
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进行划分。
sklearn 中ShuffleSplit（）函数详细解
weixin_48302334的博客
07-03 1649
ShuffleSplit()函数是交叉验证中的一种分割数据集的方法。它的作用是将原始数据集随机打乱，并按照指定的比例将数据集划分为训练集和测试集。具体来说，ShuffleSplit()函数会将数据集中的样本随机打乱，并根据设定的参数生成多个不重叠的训练集和测试集拆分。每次拆分都会返回一个新的拆分器。
python中shuffleSplit()函数的参数解释
今天你学习了吗？
01-28 2292
参数： n: int 数据集中的元素总数。 n_iter: int (default 10) 重新洗牌和分裂迭代次数。 test_size: float (default 0.1), int, or None 如果是float类型的数据, 这个数应该介于0-1.0之间，代表test集所占比例. 如果是int类型, 代表test集的数量. 如果为None, 值将自动设置为train集大小的补集 train_size: float, int, or None (default ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值