sklearn中sklearn.model_selection的应用与实践

强大的sklearn库可以解决的问题：

train_test_split返回切分的数据集train/test：

train_test_split(*array,test_size=0.25,train_size=None,random_state=None,shuffle=True,stratify=None)

*array：切分数据源（list/np.array/pd.DataFrame/scipy_sparse matrices）
test_size和train_size是互补和为1的一对值
shuffle：对数据切分前是否洗牌 stratify：是否分层抽样切分数据（If shuffle=False then stratify must be None.）

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, random_state=666,shuffle=True)
# Parameters:
# *arrays :需要进行划分的X ；
# target ：数据集的结果
# test_size :测试集占整个数据集的多少比例
# train_size :test_size +train_size = 1
# random_state : 随机种子
# shuffle : 是否洗牌 在进行划分前# 返回 X_train,X_test,y_train,y_test

x = np.arange(10).reshape([5, 2])
y = np.arange(5)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)
print(x_train)
print(y_train)

交叉验证

cross_val_score
对数据集进行指定次数的交叉验证并为每次验证效果评测
其中，score 默认是以 scoring='f1_macro’进行评测的，余外针对分类或回归还有：
分类、聚类、回归

这需要from　sklearn import metrics ,通过在cross_val_score 指定参数来设定评测标准；
当cv 指定为int 类型时，默认使用KFold 或StratifiedKFold 进行数据集打乱，

from sklearn import svm
import math
from sklearn.model_selection import train_test_split
from sklearn import datasets
from sklearn.model_selection import cross_val_score
datas = datasets.load_iris()
print(datas.keys())x_train, x_test, y_train, y_test = train_test_split(datas['data'], datas['target'], test_size=0.4, random_state=0)
clf = svm.SVC(kernel='linear', C=1).fit(x_train, y_train)
print(clf.score(x_test, y_test))# 5折调查验证
scores = cross_val_score(clf, datas['data'], datas['target'], cv=5)
print(scores.mean())

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

from sklearn import metricsdatas = datasets.load_iris()x_train, x_test, y_train, y_test = train_test_split(datas["data"], datas['target'], test_size=0.3)clf = svm.SVC(kernel='linear', C=2).fit(x_train, y_train)
print(clf.score(x_test, y_test))predicteds = cross_val_predict(clf, datas["data"], datas["target"], cv=10)
print(predicteds)print(metrics.accuracy_score(datas['target'], predicteds))

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']

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]

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]

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]

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]

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]

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]

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]

12.GroupShuffleSplit
这个是有放回抽样

n [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]

13.TimeSeriesSplit

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


```csharp
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]