3.1. 交叉验证：评估估计器性能#

学习预测函数的参数并在相同数据上进行测试是一个方法论上的错误：一个只会重复它刚刚见过的样本标签的模型会得到完美的分数，但却无法对尚未见过的数据做出任何有用的预测。这种情况称为过拟合。为了避免这种情况，在进行（监督式）机器学习实验时，通常的做法是将一部分可用数据作为测试集 X_test, y_test 留出。请注意，“实验”一词并非仅指学术用途，因为即使在商业环境中，机器学习通常也是从实验开始的。以下是模型训练中典型交叉验证工作流程的流程图。最佳参数可以通过网格搜索技术确定。

在scikit-learn中，可以使用train_test_split辅助函数快速计算训练集和测试集的随机划分。让我们加载iris数据集来拟合一个线性支持向量机

>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
>>> from sklearn import datasets
>>> from sklearn import svm

>>> X, y = datasets.load_iris(return_X_y=True)
>>> X.shape, y.shape
((150, 4), (150,))

我们现在可以快速抽样一个训练集，同时留出40%的数据用于测试（评估）我们的分类器

>>> X_train, X_test, y_train, y_test = train_test_split(
...     X, y, test_size=0.4, random_state=0)

>>> X_train.shape, y_train.shape
((90, 4), (90,))
>>> X_test.shape, y_test.shape
((60, 4), (60,))

>>> clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)
0.96

当评估估计器的不同设置（“超参数”）时，例如必须为SVM手动设置的 C 设置，仍然存在在测试集上过拟合的风险，因为可以通过调整参数直到估计器表现最佳。这样，关于测试集的知识就会“泄露”到模型中，评估指标也就不再报告泛化性能。为了解决这个问题，可以再将数据集的一部分作为所谓的“验证集”留出：训练在训练集上进行，之后在验证集上进行评估，当实验看起来成功时，最终评估可以在测试集上进行。

然而，将可用数据划分为三个集合会大大减少可用于学习模型的样本数量，并且结果可能取决于（训练，验证）集合对的特定随机选择。

解决这个问题的方法是一种称为交叉验证（简称CV）的程序。测试集仍应留作最终评估，但在进行CV时不再需要验证集。在基本方法中，称为k折CV，训练集被分成k个更小的集合（其他方法将在下面描述，但通常遵循相同的原则）。对每个k个“折叠”遵循以下过程：

使用\(k-1\)个折叠作为训练数据训练模型；
在数据的剩余部分（即，它被用作测试集来计算性能度量，例如准确率）上验证得到的模型。

然后，k折交叉验证报告的性能度量是循环中计算值的平均值。这种方法计算成本可能很高，但不会浪费太多数据（不像固定任意验证集那样），这在样本数量非常少的问题（如逆推理）中是一个主要优势。

A depiction of a 5 fold cross validation on a training set, while holding out a test set.

3.1.1. 计算交叉验证指标#

使用交叉验证的最简单方法是在估计器和数据集上调用cross_val_score辅助函数。

以下示例演示了如何通过将数据分成5个连续的部分（每次分法不同），拟合模型并计算分数来估计线性核支持向量机在iris数据集上的准确率

>>> from sklearn.model_selection import cross_val_score
>>> clf = svm.SVC(kernel='linear', C=1, random_state=42)
>>> scores = cross_val_score(clf, X, y, cv=5)
>>> scores
array([0.96, 1. , 0.96, 0.96, 1. ])

平均分数和标准差因此由下式给出

>>> print("%0.2f accuracy with a standard deviation of %0.2f" % (scores.mean(), scores.std()))
0.98 accuracy with a standard deviation of 0.02

默认情况下，在每次CV迭代中计算的分数是估计器的score方法。可以通过使用 `scoring` 参数来改变这一点

>>> from sklearn import metrics
>>> scores = cross_val_score(
...     clf, X, y, cv=5, scoring='f1_macro')
>>> scores
array([0.96, 1., 0.96, 0.96, 1.])

详情请参阅评分参数：定义模型评估规则。在Iris数据集的情况下，样本在目标类别中是平衡的，因此准确率和F1分数几乎相等。

当cv参数是一个整数时，cross_val_score默认使用KFold或StratifiedKFold策略，如果估计器派生自ClassifierMixin，则使用后者。

也可以通过传入一个交叉验证迭代器来使用其他交叉验证策略，例如

>>> from sklearn.model_selection import ShuffleSplit
>>> n_samples = X.shape[0]
>>> cv = ShuffleSplit(n_splits=5, test_size=0.3, random_state=0)
>>> cross_val_score(clf, X, y, cv=cv)
array([0.977, 0.977, 1., 0.955, 1.])

另一种选择是使用一个可迭代对象，它生成（训练，测试）分割作为索引数组，例如

>>> def custom_cv_2folds(X):
...     n = X.shape[0]
...     i = 1
...     while i <= 2:
...         idx = np.arange(n * (i - 1) / 2, n * i / 2, dtype=int)
...         yield idx, idx
...         i += 1
...
>>> custom_cv = custom_cv_2folds(X)
>>> cross_val_score(clf, X, y, cv=custom_cv)
array([1.        , 0.973])

3.1.1.1. `cross_validate` 函数和多指标评估#

cross_validate 函数与cross_val_score有两个不同之处：

它允许指定多个评估指标。
它返回一个字典，除了测试分数外，还包含拟合时间、评分时间（以及可选的训练分数、已拟合估计器、训练-测试分割索引）。

对于单指标评估，其中 `scoring` 参数是字符串、可调用对象或 None，键将是 - ['test_score', 'fit_time', 'score_time']

对于多指标评估，返回值是一个字典，包含以下键 - ['test_<scorer1_name>', 'test_<scorer2_name>', 'test_<scorer...>', 'fit_time', 'score_time']

return_train_score 默认设置为 False 以节省计算时间。若要同时评估训练集上的分数，需要将其设置为 True。您也可以通过设置 return_estimator=True 来保留每个训练集上拟合的估计器。类似地，您可以设置 return_indices=True 来保留用于将数据集划分为每个交叉验证分割的训练集和测试集的索引。

多个指标可以指定为预定义评分器名称的列表、元组或集合

>>> from sklearn.model_selection import cross_validate
>>> from sklearn.metrics import recall_score
>>> scoring = ['precision_macro', 'recall_macro']
>>> clf = svm.SVC(kernel='linear', C=1, random_state=0)
>>> scores = cross_validate(clf, X, y, scoring=scoring)
>>> sorted(scores.keys())
['fit_time', 'score_time', 'test_precision_macro', 'test_recall_macro']
>>> scores['test_recall_macro']
array([0.96, 1., 0.96, 0.96, 1.])

或者作为将评分器名称映射到预定义或自定义评分函数的字典

>>> from sklearn.metrics import make_scorer
>>> scoring = {'prec_macro': 'precision_macro',
...            'rec_macro': make_scorer(recall_score, average='macro')}
>>> scores = cross_validate(clf, X, y, scoring=scoring,
...                         cv=5, return_train_score=True)
>>> sorted(scores.keys())
['fit_time', 'score_time', 'test_prec_macro', 'test_rec_macro',
 'train_prec_macro', 'train_rec_macro']
>>> scores['train_rec_macro']
array([0.97, 0.97, 0.99, 0.98, 0.98])

以下是使用单个指标的cross_validate示例

>>> scores = cross_validate(clf, X, y,
...                         scoring='precision_macro', cv=5,
...                         return_estimator=True)
>>> sorted(scores.keys())
['estimator', 'fit_time', 'score_time', 'test_score']

3.1.1.2. 通过交叉验证获得预测#

函数cross_val_predict的接口与cross_val_score相似，但它返回输入中每个元素在作为测试集时获得的预测。只能使用将所有元素分配给测试集恰好一次的交叉验证策略（否则会引发异常）。

警告

关于cross_val_predict不当使用的注意事项

cross_val_predict的结果可能与使用cross_val_score获得的结果不同，因为元素的组合方式不同。cross_val_score对交叉验证折叠进行平均，而cross_val_predict只是返回来自几个不同模型的未区分的标签（或概率）。因此，cross_val_predict不是泛化误差的合适度量。

函数cross_val_predict适用于：

可视化从不同模型获得的预测。
模型融合：当一个监督估计器的预测被用于在集成方法中训练另一个估计器时。

可用的交叉验证迭代器将在下一节介绍。

示例

3.1.2. 交叉验证迭代器#

以下部分列出了生成索引的实用程序，这些索引可用于根据不同的交叉验证策略生成数据集分割。

3.1.2.1. i.i.d.数据的交叉验证迭代器#

假设某些数据是独立同分布（i.i.d.）意味着所有样本都源自相同的生成过程，并且该生成过程被认为对过去生成的样本没有记忆。

在这些情况下，可以使用以下交叉验证器。

注意

虽然i.i.d.数据在机器学习理论中是一个常见的假设，但在实践中很少成立。如果已知样本是使用时间依赖过程生成的，则使用时间序列感知的交叉验证方案更安全。类似地，如果我们知道生成过程具有分组结构（从不同主题、实验、测量设备收集的样本），则使用按组交叉验证更安全。

3.1.2.1.1. K折#

KFold 将所有样本分成\(k\)个样本组，称为折叠（如果\(k = n\)，则等同于留一法策略），大小相等（如果可能）。预测函数使用\(k - 1\)个折叠进行学习，剩余的折叠用于测试。

在包含4个样本的数据集上进行2折交叉验证的示例

>>> import numpy as np
>>> from sklearn.model_selection import KFold

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

这是交叉验证行为的可视化。请注意，KFold不受类别或组的影响。

../_images/sphx_glr_plot_cv_indices_006.png

每个折叠由两个数组组成：第一个与训练集相关，第二个与测试集相关。因此，可以使用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]

3.1.2.1.2. 重复K折#

RepeatedKFold将KFold重复\(n\)次，每次重复产生不同的分割。

2折K折重复2次的示例

>>> import numpy as np
>>> from sklearn.model_selection import RepeatedKFold
>>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
>>> random_state = 12883823
>>> rkf = RepeatedKFold(n_splits=2, n_repeats=2, random_state=random_state)
>>> for train, test in rkf.split(X):
...     print("%s %s" % (train, test))
...
[2 3] [0 1]
[0 1] [2 3]
[0 2] [1 3]
[1 3] [0 2]

类似地，RepeatedStratifiedKFold将StratifiedKFold重复\(n\)次，每次重复进行不同的随机化。

3.1.2.1.3. 留一法 (LOO)#

LeaveOneOut（或LOO）是一种简单的交叉验证方法。每个学习集都是通过移除一个样本来创建的，测试集就是被移除的那个样本。因此，对于\(n\)个样本，我们有\(n\)个不同的训练集和\(n\)个不同的测试集。这种交叉验证过程不会浪费太多数据，因为训练集中只移除一个样本。

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

模型选择的LOO潜在用户应权衡一些已知注意事项。与\(k\)折交叉验证相比，LOO从\(n\)个样本构建\(n\)个模型，而不是\(k\)个模型，其中\(n > k\)。此外，每个模型都在\(n - 1\)个样本而不是\((k-1) n / k\)个样本上进行训练。从这两个方面来看，假设\(k\)不太大且\(k < n\)，LOO比\(k\)折交叉验证的计算成本更高。

就准确性而言，LOO作为测试误差的估计器，通常会导致高方差。直观地说，由于\(n\)个样本中的\(n - 1\)个样本用于构建每个模型，因此从折叠构建的模型彼此之间以及与从整个训练集构建的模型几乎相同。

然而，如果对于所讨论的训练集大小，学习曲线很陡峭，那么5或10折交叉验证可能会高估泛化误差。

作为一般规则，大多数作者和经验证据表明，5或10折交叉验证应优于LOO。

3.1.2.1.4. 留P法 (LPO)#

LeavePOut与LeaveOneOut非常相似，它通过从完整集中移除\(p\)个样本来创建所有可能的训练/测试集。对于\(n\)个样本，这会产生\({n \choose p}\)个训练-测试对。与LeaveOneOut和KFold不同，对于\(p > 1\)，测试集将重叠。

在包含4个样本的数据集上进行留2法交叉验证的示例

>>> from sklearn.model_selection import LeavePOut

>>> X = np.ones(4)
>>> lpo = LeavePOut(p=2)
>>> for train, test in lpo.split(X):
...     print("%s %s" % (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]

3.1.2.1.5. 随机置换交叉验证，又称Shuffle & Split#

ShuffleSplit迭代器将生成用户定义的独立训练/测试数据集分割数量。样本首先被打乱，然后分成一对训练集和测试集。

通过显式地为random_state伪随机数生成器设置种子，可以控制随机性以实现结果的可重复性。

以下是一个使用示例

>>> from sklearn.model_selection import ShuffleSplit
>>> X = np.arange(10)
>>> ss = ShuffleSplit(n_splits=5, test_size=0.25, random_state=0)
>>> for train_index, test_index in ss.split(X):
...     print("%s %s" % (train_index, test_index))
[9 1 6 7 3 0 5] [2 8 4]
[2 9 8 0 6 7 4] [3 5 1]
[4 5 1 0 6 9 7] [2 3 8]
[2 7 5 8 0 3 4] [6 1 9]
[4 1 0 6 8 9 3] [5 2 7]

这是交叉验证行为的可视化。请注意，ShuffleSplit不受类别或组的影响。

../_images/sphx_glr_plot_cv_indices_008.png

因此，ShuffleSplit是KFold交叉验证的一个很好的替代方案，它允许更精细地控制迭代次数以及训练/测试分割中样本的比例。

3.1.2.2. 基于类别标签分层的交叉验证迭代器#

某些分类任务自然会表现出稀有类别：例如，负样本观察值可能比正样本观察值多几个数量级（例如医疗筛查、欺诈检测等）。因此，交叉验证分割可能会生成不包含任何特定类别的训练或验证折叠。这通常会导致未定义的分类指标（例如ROC AUC）、尝试调用fit时引发异常，或者在对不同折叠训练的多分类器的predict_proba或decision_function方法的输出中缺少列。

为了缓解此类问题，分割器如StratifiedKFold和StratifiedShuffleSplit实现了分层抽样，以确保相对类别频率在每个折叠中近似保留。

注意

分层抽样被引入scikit-learn是为了解决上述工程问题，而非统计问题。

分层使交叉验证折叠更均匀，因此隐藏了拟合有限观测模型所固有的某些可变性。

结果，分层可能会人为地缩小跨交叉验证迭代测量的指标的分布：折叠间变异性不再反映分类器在存在稀有类别时的性能不确定性。

3.1.2.2.1. 分层K折#

StratifiedKFold是K折的一种变体，它返回分层折叠：每个集合包含的每个目标类别的样本百分比与完整集合近似相同。

以下是在一个包含50个样本、来自两个不平衡类别的数据集上进行分层3折交叉验证的示例。我们展示了每个类别中的样本数量，并与KFold进行比较。

>>> from sklearn.model_selection import StratifiedKFold, KFold
>>> import numpy as np
>>> X, y = np.ones((50, 1)), np.hstack(([0] * 45, [1] * 5))
>>> skf = StratifiedKFold(n_splits=3)
>>> for train, test in skf.split(X, y):
...     print('train -  {}   |   test -  {}'.format(
...         np.bincount(y[train]), np.bincount(y[test])))
train -  [30  3]   |   test -  [15  2]
train -  [30  3]   |   test -  [15  2]
train -  [30  4]   |   test -  [15  1]
>>> kf = KFold(n_splits=3)
>>> for train, test in kf.split(X, y):
...     print('train -  {}   |   test -  {}'.format(
...         np.bincount(y[train]), np.bincount(y[test])))
train -  [28  5]   |   test -  [17]
train -  [28  5]   |   test -  [17]
train -  [34]   |   test -  [11  5]

我们可以看到StratifiedKFold在训练集和测试集中都保留了类别比例（大约1/10）。

这是交叉验证行为的可视化。

../_images/sphx_glr_plot_cv_indices_009.png

RepeatedStratifiedKFold 可用于重复分层 K 折交叉验证 n 次，每次重复使用不同的随机化。

3.1.2.2.2. 分层洗牌分割#

StratifiedShuffleSplit是ShuffleSplit的一个变体，它返回分层分割，即通过保持每个目标类别的百分比与完整集合相同来创建分割。

这是交叉验证行为的可视化。

../_images/sphx_glr_plot_cv_indices_012.png

3.1.2.3. 预定义折叠分割/验证集#

对于某些数据集，数据已经预先定义了训练-验证折叠或多个交叉验证折叠的分割。使用PredefinedSplit可以利用这些折叠，例如在搜索超参数时。

例如，当使用验证集时，将验证集中的所有样本的test_fold设置为0，将所有其他样本的test_fold设置为-1。

3.1.2.4. 分组数据的交叉验证迭代器#

如果底层生成过程产生依赖样本组，则i.i.d.假设被打破。

这种数据分组是领域特有的。一个例子是当有从多个患者收集的医疗数据，每个患者采集了多个样本。这些数据很可能依赖于个体组。在我们的例子中，每个样本的患者ID将是其组标识符。

在这种情况下，我们希望知道在特定组集上训练的模型是否能很好地推广到未见过的组。为了衡量这一点，我们需要确保验证折叠中的所有样本都来自在配对训练折叠中完全没有表示的组。

以下交叉验证分割器可用于此目的。样本的分组标识符通过groups参数指定。

3.1.2.4.1. 分组K折#

GroupKFold是K折的一种变体，它确保同一个组不会同时出现在测试集和训练集中。例如，如果数据来自不同受试者，每个受试者有多个样本，并且如果模型足够灵活，能够从高度个性化的特征中学习，那么它可能无法泛化到新受试者。GroupKFold使得检测这类过拟合情况成为可能。

假设您有三个受试者，每个受试者都有一个从1到3的关联数字

>>> from sklearn.model_selection import GroupKFold

>>> X = [0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 8.8, 9, 10]
>>> y = ["a", "b", "b", "b", "c", "c", "c", "d", "d", "d"]
>>> groups = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3]

>>> gkf = GroupKFold(n_splits=3)
>>> for train, test in gkf.split(X, y, groups=groups):
...     print("%s %s" % (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]

每个受试者都在一个不同的测试折叠中，并且同一个受试者从不同时出现在测试和训练中。请注意，由于数据不平衡，这些折叠的大小并不完全相同。如果需要平衡折叠之间的类别比例，StratifiedGroupKFold是更好的选择。

这是交叉验证行为的可视化。

../_images/sphx_glr_plot_cv_indices_007.png

与KFold类似，GroupKFold的测试集将构成所有数据的完整分区。

当shuffle=False时，GroupKFold尝试将相同数量的样本放入每个折叠中；当shuffle=True时，它尝试将相同数量的不同组放入每个折叠中（但不考虑组大小）。

3.1.2.4.2. 分层分组K折#

StratifiedGroupKFold是一种结合了StratifiedKFold和GroupKFold的交叉验证方案。其思想是尝试在每个分割中保留类别的分布，同时将每个组保持在单个分割内。当数据集不平衡时，这可能很有用，因为仅使用GroupKFold可能会产生倾斜的分割。

示例

>>> from sklearn.model_selection import StratifiedGroupKFold
>>> X = list(range(18))
>>> y = [1] * 6 + [0] * 12
>>> groups = [1, 2, 3, 3, 4, 4, 1, 1, 2, 2, 3, 4, 5, 5, 5, 6, 6, 6]
>>> sgkf = StratifiedGroupKFold(n_splits=3)
>>> for train, test in sgkf.split(X, y, groups=groups):
...     print("%s %s" % (train, test))
[ 0  2  3  4  5  6  7 10 11 15 16 17] [ 1  8  9 12 13 14]
[ 0  1  4  5  6  7  8  9 11 12 13 14] [ 2  3 10 15 16 17]
[ 1  2  3  8  9 10 12 13 14 15 16 17] [ 0  4  5  6  7 11]

以下是针对不均匀组的交叉验证行为的可视化

../_images/sphx_glr_plot_cv_indices_005.png

3.1.2.4.3. 留一组法#

LeaveOneGroupOut是一种交叉验证方案，其中每个分割都留出属于一个特定组的样本。组信息通过一个数组提供，该数组编码每个样本所属的组。

因此，每个训练集都由除特定组相关样本之外的所有样本组成。这与LeavePGroupsOut的n_groups=1情况相同，也与GroupKFold的n_splits等于传递给groups参数的唯一标签数量的情况相同。

例如，在多个实验的情况下，LeaveOneGroupOut可用于创建基于不同实验的交叉验证：我们使用除一个实验之外的所有实验的样本来创建训练集。

>>> from sklearn.model_selection import LeaveOneGroupOut

>>> X = [1, 5, 10, 50, 60, 70, 80]
>>> y = [0, 1, 1, 2, 2, 2, 2]
>>> groups = [1, 1, 2, 2, 3, 3, 3]
>>> logo = LeaveOneGroupOut()
>>> for train, test in logo.split(X, y, groups=groups):
...     print("%s %s" % (train, test))
[2 3 4 5 6] [0 1]
[0 1 4 5 6] [2 3]
[0 1 2 3] [4 5 6]

另一个常见的应用是使用时间信息：例如，这些组可以是样本的收集年份，从而允许进行基于时间的交叉验证分割。

3.1.2.4.4. 留P组法#

LeavePGroupsOut与LeaveOneGroupOut相似，但它为每个训练/测试集移除\(P\)组样本。所有可能的\(P\)组组合都被留出，这意味着对于\(P>1\)，测试集将重叠。

留2组法示例

>>> from sklearn.model_selection import LeavePGroupsOut

>>> X = 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("%s %s" % (train, test))
[4 5] [0 1 2 3]
[2 3] [0 1 4 5]
[0 1] [2 3 4 5]

3.1.2.4.5. 分组洗牌分割#

GroupShuffleSplit迭代器的行为类似于ShuffleSplit和LeavePGroupsOut的组合，它生成一系列随机分区，其中每进行一次分割都会留出一部分组。

以下是一个使用示例

>>> from sklearn.model_selection import GroupShuffleSplit

>>> X = [0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 0.001]
>>> y = ["a", "b", "b", "b", "c", "c", "c", "a"]
>>> groups = [1, 1, 2, 2, 3, 3, 4, 4]
>>> gss = GroupShuffleSplit(n_splits=4, test_size=0.5, random_state=0)
>>> for train, test in gss.split(X, y, groups=groups):
...     print("%s %s" % (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]

这是交叉验证行为的可视化。

../_images/sphx_glr_plot_cv_indices_011.png

当需要LeavePGroupsOut的行为，但组的数量足够大，以至于生成所有可能的\(P\)组保留分区会非常昂贵时，这个类很有用。在这种情况下，GroupShuffleSplit提供了由LeavePGroupsOut生成的训练/测试分割的随机样本（有放回抽取）。

3.1.2.5. 使用交叉验证迭代器分割训练集和测试集#

上述分组交叉验证函数也可用于将数据集分割成训练集和测试集子集。请注意，便捷函数train_test_split是ShuffleSplit的包装器，因此只允许分层分割（使用类别标签），而不能考虑组。

要执行训练集和测试集分割，请使用交叉验证分割器的split()方法生成的训练集和测试集子集的索引。例如

>>> import numpy as np
>>> from sklearn.model_selection import GroupShuffleSplit

>>> X = np.array([0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 0.001])
>>> y = np.array(["a", "b", "b", "b", "c", "c", "c", "a"])
>>> groups = np.array([1, 1, 2, 2, 3, 3, 4, 4])
>>> train_indx, test_indx = next(
...     GroupShuffleSplit(random_state=7).split(X, y, groups)
... )
>>> X_train, X_test, y_train, y_test = \
...     X[train_indx], X[test_indx], y[train_indx], y[test_indx]
>>> X_train.shape, X_test.shape
((6,), (2,))
>>> np.unique(groups[train_indx]), np.unique(groups[test_indx])
(array([1, 2, 4]), array([3]))

3.1.2.6. 时间序列数据的交叉验证#

时间序列数据的特点是时间上相近的观测值之间存在相关性（自相关性）。然而，传统的交叉验证技术，如KFold和ShuffleSplit，假设样本是独立同分布的，这会导致训练实例和测试实例之间存在不合理的相关性（从而产生泛化误差的糟糕估计）在时间序列数据上。因此，评估我们的时间序列模型在“未来”观测值上的表现至关重要，这些观测值与用于训练模型的观测值差异最大。为了实现这一点，TimeSeriesSplit提供了一种解决方案。

3.1.2.6.1. 时间序列分割#

TimeSeriesSplit是k折的一种变体，它返回前\(k\)个折叠作为训练集，第\((k+1)\)个折叠作为测试集。请注意，与标准交叉验证方法不同，连续的训练集是其前一个训练集的超集。此外，它将所有剩余数据添加到第一个训练分区，该分区始终用于训练模型。

此类别可用于对以固定时间间隔观察到的时间序列数据样本进行交叉验证。实际上，为了使折叠之间的指标具有可比性，折叠必须代表相同的持续时间。

包含6个样本的数据集上3分割时间序列交叉验证的示例

>>> from sklearn.model_selection import TimeSeriesSplit

>>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
>>> y = np.array([1, 2, 3, 4, 5, 6])
>>> tscv = TimeSeriesSplit(n_splits=3)
>>> print(tscv)
TimeSeriesSplit(gap=0, max_train_size=None, n_splits=3, test_size=None)
>>> for train, test in tscv.split(X):
...     print("%s %s" % (train, test))
[0 1 2] [3]
[0 1 2 3] [4]
[0 1 2 3 4] [5]

这是交叉验证行为的可视化。

../_images/sphx_glr_plot_cv_indices_013.png

3.1.3. 关于洗牌的注意事项#

如果数据排序不是任意的（例如，具有相同类别标签的样本是连续的），那么首先对其进行洗牌可能对于获得有意义的交叉验证结果至关重要。然而，如果样本不是独立同分布的，则情况可能恰恰相反。例如，如果样本对应新闻文章，并且按其发布时间排序，那么打乱数据可能会导致模型过拟合，并导致验证分数虚高：它将在与训练样本人为相似（时间上接近）的样本上进行测试。

一些交叉验证迭代器，如KFold，具有内置选项，可在分割数据之前对其索引进行洗牌。请注意：

这比直接洗牌数据消耗的内存更少。
默认情况下不进行洗牌，包括通过向cross_val_score、网格搜索等指定cv=some_integer所执行的（分层）K折交叉验证。请记住，train_test_split仍然返回随机分割。
random_state参数默认为None，这意味着每次迭代KFold(..., shuffle=True)时，洗牌结果都会不同。然而，GridSearchCV在其fit方法的一次调用中，将对每个验证的参数集使用相同的洗牌。
要获得每个分割的相同结果，请将random_state设置为整数。

有关如何控制CV分割器的随机性并避免常见陷阱的更多详细信息，请参阅控制随机性。

3.1.4. 交叉验证和模型选择#

交叉验证迭代器也可以用于直接使用网格搜索来执行模型选择，以找到模型的最佳超参数。这是下一节的主题：调整估计器的超参数。

3.1.5. 置换检验分数#

permutation_test_score提供了另一种评估预测器性能的方法。它提供了一个基于置换的p值，表示估计器获得观察到的性能的可能性有多大。该检验中的零假设是估计器未能利用特征与目标之间的任何统计依赖性来对留出数据进行正确预测。permutation_test_score通过计算n_permutations个不同置换的数据来生成空分布。在每次置换中，目标值被随机打乱，从而消除了特征与目标之间的任何依赖关系。输出的p值是交叉验证分数优于或等于不置换目标时的真实分数的置换比例。为了获得可靠结果，n_permutations通常应大于100，cv介于3-10折之间。

较低的p值表明数据集包含特征和目标之间存在某些真实依赖关系，并且估计器能够利用这种依赖关系获得良好结果。反之，较高的p值可能由于以下原因之一：

特征和目标之间缺乏依赖性（即，没有系统关系，任何观察到的模式很可能仅仅是随机的）
或者是因为估计器未能利用数据中的依赖关系（例如，因为它欠拟合）。

在后一种情况下，使用能够利用数据中结构化的更合适的估计器将导致更低的p值。

交叉验证通过估计其预期分数的范围来提供有关估计器泛化能力的信息。然而，在没有结构的高维数据集上训练的估计器可能仍然在交叉验证中表现优于预期，这仅仅是偶然的。这通常发生在样本数量少于几百个的小型数据集上。permutation_test_score提供了关于估计器是否找到了特征和目标之间的真实依赖关系的信息，并且可以帮助评估估计器的性能。

需要注意的是，即使数据中只有微弱的结构，该测试也已被证明会产生较低的p值，因为在相应的置换数据集中绝对没有结构。因此，该测试只能显示模型是否可靠地优于随机猜测。

最后，permutation_test_score通过暴力计算，内部拟合(n_permutations + 1) * n_cv个模型。因此，它仅适用于拟合单个模型非常快的小型数据集。使用n_jobs参数可并行化计算，从而加快速度。

示例

通过置换测试分类分数的显著性

3.1. 交叉验证：评估估计器性能#

3.1.1. 计算交叉验证指标#

3.1.1.1. cross_validate 函数和多指标评估#

3.1.1.2. 通过交叉验证获得预测#

3.1.2. 交叉验证迭代器#

3.1.2.1. i.i.d.数据的交叉验证迭代器#

3.1.2.1.1. K折#

3.1.2.1.2. 重复K折#

3.1.2.1.3. 留一法 (LOO)#

3.1.2.1.4. 留P法 (LPO)#

3.1.2.1.5. 随机置换交叉验证，又称Shuffle & Split#

3.1.2.2. 基于类别标签分层的交叉验证迭代器#

3.1.2.2.1. 分层K折#

3.1.2.2.2. 分层洗牌分割#

3.1.2.3. 预定义折叠分割/验证集#

3.1.2.4. 分组数据的交叉验证迭代器#

3.1.2.4.1. 分组K折#

3.1.2.4.2. 分层分组K折#

3.1.2.4.3. 留一组法#

3.1.2.4.4. 留P组法#

3.1.2.4.5. 分组洗牌分割#

3.1.2.5. 使用交叉验证迭代器分割训练集和测试集#

3.1.2.6. 时间序列数据的交叉验证#

3.1.2.6.1. 时间序列分割#

3.1.3. 关于洗牌的注意事项#

3.1.4. 交叉验证和模型选择#

3.1.5. 置换检验分数#

本页

3.1.1.1. `cross_validate` 函数和多指标评估#