[转]sklearn中的交叉验证和数据划分

正文

train_test_split

给定一个训练数据集合，寻找一个模型去fit这个训练数据，如果在全部的训练数据上训练获得模型并且在全部的训练数据上测试模型，则测试结果会很好；
但是对于未知的数据泛化效果会很不好，即过拟合。所以需要在不同的数据集上训练和测试。

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn import datasets
from sklearn import svm
iris = datasets.load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=0)

train_test_split将数据划分成训练集合和测试集合，random_state参数设置使得能够固定随机划分。test_size即为测试集占比。

先前基础上加入以下代码：

clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)
print clf.score(X_test, y_test) #输出0.966666666667

交叉验证

针对SVM模型而言，如果只将原有的训练数据划分为训练集和测试集，必须人工设定参数C，模型在测试集合上依然存在过拟合的风险。
因为这个参数会不断优化使得其在测试集上取得最佳的性能，这时候测试集的内容就会被泄露到模型中，由测试集得到的评价指标不再能够反映出泛化的性能。
为了解决这个问题，可以将原有的训练数据划分为训练集、验证集和测试集三个部分，在训练集上训练，再在验证集上评估，最后在测试集上进行评价。
这样泄露的只是验证集上的数据，而测试集的数据不会泄漏，能够得到无干扰的泛化性能指标。
但是针对数据量较小的训练数据这样划分数据集会使得训练集的量不够，无法得到有效的训练，同时随机划分这三个集合也会造成最终结果一定的随机性。

可以用交叉验证的方式解决这个问题。基本的方法称为k折交叉验证，下面介绍sklearn中的交叉验证

• 先前基础上加入以下代码

from sklearn.model_selection import cross_val_score
clf = svm.SVC(kernel='linear', C=1)
scores = cross_val_score(clf, iris.data, iris.target, cv=5)  #线性SVM连续5次采用不同方法划分数据拟合并评分
print scores  #输出[ 0.96666667  1.          0.96666667  0.96666667  1.        ]
print scores.mean()  #输出平均分数0.98

默认地，每次 CV 迭代获得的分数由估计器的 score 函数计算得到。可以通过分数参数来改变计算方式，如下：

• 先前基础上加入以下代码:

 from sklearn import metrics
 scores = cross_val_score(clf, iris.data, iris.target, cv=5, scoring='f1_macro')
 print scores   #输出[ 0.96658312  1.          0.96658312  0.96658312  1.        ]       

此处的scoring参数可以设置为accuracy，f1等值，用于分类、聚类或回归的结果评价。
具体结果scoring设置可参考网页：http://sklearn.lzjqsdd.com/modules/model_evaluation.html#scoring-parameter

当 cv 参数是一个整数时，cross_val_score 默认地使用 KFold 或者 StratifiedKFold 策略

数据标准化

对于同一个模型的验证，测试集上的数据标准化应该与训练集一致

• 先前基础上加入以下代码

from sklearn import preprocessing
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=0)
scaler = preprocessing.StandardScaler().fit(X_train)
X_train_transformed = scaler.transform(X_train)
clf = svm.SVC(C=1).fit(X_train_transformed, y_train)
X_test_transformed = scaler.transform(X_test)
print clf.score(X_test_transformed, y_test) #输出0.933333333333

可以使用pipeline将数据标准化和交叉验证结合起来

• 先前基础上加入以下代码

 from sklearn.pipeline import make_pipeline
 clf = make_pipeline(preprocessing.StandardScaler(), svm.SVC(C=1))
 print cross_val_score(clf, iris.data, iris.target, cv=5) #输出[ 0.96666667  0.96666667  0.96666667  0.93333333  1.        ]

cross_val_predict 、 cross_val_score和cross_validate

介绍一下函数 cross_val_predict，除了返回结果不同，函数 cross_val_predict 具有和 cross_val_score 相同的接口。
这个计算的结果和 cross_val_score 有轻微的差别，因为两者用了不同的方式组织元素。

 from sklearn.model_selection import cross_val_predict
 predicted = cross_val_predict(clf, iris.data, iris.target, cv=10)
 print metrics.accuracy_score(iris.target, predicted) #输出0.973333333333

介绍一下函数cross_validate，它与cross_val_score有两点不同：

1. 允许设置多个度量评价
2. It returns a dict containing training scores, fit-times and score-times in addition to the test score.
   对于单个度量评价，返回的dict的key值为['test_score', 'fit_time', 'score_time']
   对于多个度量评价，返回的dict的key值为：
   ['test_<scorer1_name', 'test_<scorer2_name', 'test_<scorer...', 'fit_time', 'score_time']
   参数return_train_score默认设置为True，会输出训练集的train score，设置为False则不输出。

• 添加如下代码

 from sklearn.model_selection import cross_validate
 from sklearn.metrics import recall_score

 # scoring = ['precision_macro', 'recall_macro']
 #输出{'test_precision_macro': array([ 0.96969697,  1.        ,  0.96969697,  0.96969697,  1.        ]), 'train_recall_macro': array([ 0.975     ,  0.975     ,  0.99166667,  0.98333333,  0.98333333]), 'score_time': array([ 0.00099993,  0.00099993,  0.00099993,  0.00099993,  0.00099993]), 'fit_time': array([ 0.00099993,  0.        ,  0.00099993,  0.        ,  0.        ]), 'test_recall_macro': array([ 0.96666667,  1.        ,  0.96666667,  0.96666667,  1.        ]), 'train_precision_macro': array([ 0.97674419,  0.97674419,  0.99186992,  0.98412698,  0.98333333])}
 scoring = 'accuracy'
 clf = svm.SVC(kernel='linear', C=1, random_state=0)
 scores = cross_validate(clf, iris.data, iris.target, scoring=scoring,cv=5, return_train_score=True)
 print scores
 #输出{'score_time': array([ 0.        ,  0.        ,  0.00099993,  0.        ,  0.00100017]), 'test_score': array([ 0.96666667,  1.        ,  0.96666667,  0.96666667,  1.        ]), 'train_score': array([ 0.975     ,  0.975     ,  0.99166667,  0.98333333,  0.98333333]), 'fit_time': array([ 0.        ,  0.00099993,  0.        ,  0.00099993,  0.        ])}

数据集划分

以下介绍为数据集的划分方法。
列出了一些用于生成索引标号，用于在不同的交叉验证策略中生成数据划分的工具。

• 在 4 个样例的数据集上使用 2-fold 交叉验证的例子:

 X = ["a", "b", "c", "d"]
 kf = KFold(n_splits=2)
 print kf
 for train, test in kf.split(X):
     print train,test
 #输出 
 #[2 3] [0 1]
 #[0 1] [2 3]

每个折叠由两个数组组成，第一个作为 training set，另一个作为 test set；由此，可以通过使用 numpy 的索引创建训练/测试集合。

 X = np.array([[0., 0.], [1., 1.], [-1., -1.], [2., 2.]])
 y = np.array([0, 1, 0, 1])
 X_train, X_test, y_train, y_test = X[train], X[test], y[train], y[test]
 #输出
 #[[ 0.  0.]
 # [ 1.  1.]] [[-1. -1.]
 # [ 2.  2.]] [0 1] [0 1]

StratifiedKFold

StratifiedKFold是k-fold 的变种，会返回分层的折叠：每个小集合中，各个类别的样例比例大致和完整数据集中相同。

在有10个样例的，有两个略不均衡类别的数据集上进行分层 3-fold 交叉验证的例子。

 from sklearn.model_selection import StratifiedKFold
 X = np.ones(10)
 print X
 y = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
 skf = StratifiedKFold(n_splits=3)
 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]


 Leave One Out (LOO)
 from sklearn.model_selection import LeaveOneOut
 X = [1, 2, 3, 4]
 loo = LeaveOneOut()
 for train, test in loo.split(X):
 print("%s %s" % (train, test))
 #[1 2 3] [0]
 #[0 2 3] [1]
 #[0 1 3] [2]
 #[0 1 2] [3]

经验证据表明5-或者10-的折叠交叉验证要好于LeaveOneOut。

Random permutations cross-validation a.k.a. Shuffle & Split
ShuffleSplit 迭代器 将会生成一个用户给定数量的独立的训练/测试数据划分。样例首先被打散然后划分为一对训练测试集合。
可以通过设定明确的 random_state，使得伪随机生成器的结果可以重复。

from sklearn.model_selection import ShuffleSplit
X = np.arange(5)
ss = ShuffleSplit(n_splits=3, test_size=0.25,random_state=0)
for train_index, test_index in ss.split(X):
    print("%s %s" % (train_index, test_index))
#输出：
#[1 3 4] [2 0]
#[1 4 3] [0 2]
#[4 0 2] [1 3]


 Repeated K-Fold
 Leave-P-Out - LPO

参考文献

• http://scikit-learn.org/stable/modules/cross_validation.html
• http://sklearn.lzjqsdd.com/modules/cross_validation.html#leave-p-out-lpo
• https://www.cnblogs.com/nolonely/p/7007432.html
• http://blog.csdn.net/kancy110/article/details/74910185
• https://www.cnblogs.com/hellcat/p/7045585.html

---

转自sklearn中的交叉验证和数据划分