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

最新推荐文章于 2020-12-21 10:51:26 发布
最新推荐文章于 2020-12-21 10:51:26 发布
阅读量1.2k 收藏 5
点赞数 1
分类专栏： PYTHON_机器学习

原理介绍

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]
骁勇善栈
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Python机器学习】零基础掌握GroupShuffleSplit交叉验证
Mr数据杨
11-03 81
通过本文的深入解析对这一强大的数据划分工具有了全面而深刻的认识。通过结合足球运动员的实际案例展示了如何利用按组结构准确划分数据集，确保训练集和测试集中的数据分布更加均衡和公正。代码演示和数据可视化进一步加深了对该算法运作方式的理解，使得即使是对机器学习不熟悉的小伙伴也能够轻松把握其核心要点。优点总结，在处理具有组结构的数据时展现出了显著的优势，能够有效避免数据泄漏，提升模型评估的准确性。优点描述避免数据泄漏确保同一组内的数据不会同时出现在训练集和测试集中提升模型评估准确性。
Scikit-learn文本分类
09-02
包含4部分数据下载，提取特征，Pipline 训练模型，GridSearchCV 寻找最优参数。用到的算法，NB, KNN,SVM,
sklearn ShuffleSplit.split()使用说明，内有大坑（结合for循环清零问题）
weixin_43843003的博客
09-13 3879
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的用法。
Scikit-learn的ShuffleSplit与GroupShuffleSplit
gaocui883的博客
12-21 574
官方文档说明： 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
在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+python:线性回归案例
09-17
首先，我们需要导入必要的库，包括`load_boston`来获取波士顿房价数据集，`train_test_split`来进行数据划分，以及`LinearRegression`来构建线性回归模型。波士顿房价数据集包含了13个特征，如犯罪率（CRIM）、住宅...
Python sklearn KFold 生成交叉验证数据集的方法
09-19
此外，如果需要将生成的交叉验证数据集保存为 CSV 文件，可以编写如上文代码所示的函数。`writeInFile()` 函数接受不同状态（良性、恶意）的数据集和 KFold 得到的索引，然后分别写入训练集和测试集文件。这里的关键...
python 划分数据集为训练集和测试集的方法
09-19
这种方法确保了数据划分的随机性，有助于提高模型评估的公正性。 总结来说，`train_test_split`函数和自定义函数都是有效的方法，可以根据项目需求和数据特性选择合适的方式划分数据集。正确地划分训练集和测试集，...
对sklearn的使用之数据集的拆分与训练详解(python3.6)
09-19
`sklearn`库是Python中最常用的机器学习库之一，提供了丰富的数据处理和模型训练功能。本文将深入讲解如何在Python 3.6环境下利用`sklearn`进行数据集的拆分与训练。 首先，我们导入所需的库，包括`datasets`、`...
sklearn的模型选择和评估之交叉验证
koukehui0292的博客
10-15 1914
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...
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中的交叉验证（Cross-Validation）
热门推荐
Great haste makes great waste
05-14 13万+
这个repo 用来记录一些python技巧、书籍、学习链接等，欢迎star github地址 sklearn是利用python进行机器学习中一个非常全面和好用的第三方库，用过的都说好。今天主要记录一下sklearn中关于交叉验证的各种用法，主要是对sklearn官方文档 Cross-validation: evaluating estimator performance进行讲解，英文水平好...
python中sklearn实现交叉验证
跨语言，跨平台，跨应用
05-04 2万+
1、概述在实验数据分析中，有些算法需要用现有的数据构建模型，如卷积神经网络（CNN），这类算法称为监督学习（Supervisied Learning）。构建模型需要的数据称为训练数据。模型构建完后，需要利用数据验证模型的正确性，这部分数据称为测试数据。测试数据不能用于构建模型中，只能用于最后检验模型的准确性。有时候模型的构建的过程中，也需要检验模型，辅助模型构建。所以会将训练数据分为两个部分，1）训
机器学习-->sklearn.Cross-validation
村头陶员外的博客
06-18 4191
本篇博文将主详细讲机器学习模型选择中的交叉验证，全文翻译自sklearn.Cross-Validation。并且加上了我自己的一些见解。 学习预测函数的参数并在相同的数据上进行测试是一个方法上的错误：一个在训练集上能取得很好的成绩的模型，但是在测试集上效果却很差，这种情况称为过拟合。为了避免这种情况，通常（监督）机器学习实验时将一部分可用数据保存为测试集X_test，y_test。train_te
划分训练集和测试集的方法及sklearn实现
Alinawly的博客
06-27 1万+
1.留出法（hold-out）直接将数据集D划分为两个互斥的集合，训练集S、测试集T，用S训练模型，用T来评估其测试误差。需要注意划分时尽可能保持数据分布的一致性，保持样本类别比例相似。可采用分层采样的方式。在使用留出法时，一般要采用若干次随机划分、重复进行实验评估后取平均值作为留出法的评估结果。通常情况下我们将2/3~4/5的样本划分出来用于训练。使用sklearn.model_selectio...
python中shuffleSplit（）函数
pywin
04-21 1万+
参数： n : int 数据集中的元素总数。 n_iter : int (default 10) 重新洗牌和分裂迭代次数。 test_size : float (default 0.1), int, or None 如果是float类型的数据, 这个数应该介于0-1.0之间，代表test集所占比例. 如果是int类型, 代表test集的数量. 如
给出使用sklearn开源库的具体Python代码
最新发布
06-02
下面是使用sklearn库中的MLPClassifier类实现心跳信号分类的Python代码示例： ```python import pandas as pd from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split from sklearn.neural_network import MLPClassifier # 读取数据集 data = pd.read_csv('heart_rate.csv') # 划分特征和标签 X = data.drop('label', axis=1) y = data['label'] # 数据预处理 scaler = StandardScaler() X = scaler.fit_transform(X) # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) # 构建BP神经网络模型 clf = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=500, alpha=0.01, solver='adam', verbose=False, tol=1e-4, random_state=42) # 训练模型 clf.fit(X_train, y_train) # 预测测试集 y_pred = clf.predict(X_test) # 计算分类准确率等指标 accuracy = clf.score(X_test, y_test) print("Accuracy:", accuracy) ``` 这段代码中，首先读取心跳信号数据集，并使用StandardScaler类进行数据预处理，然后使用train_test_split函数将数据划分为训练集和测试集。接着，使用MLPClassifier类构建BP神经网络模型，并设置相关参数。最后，使用fit函数对训练集进行训练，使用predict函数对测试集进行预测，并使用score函数计算分类准确率等指标。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值