Splitting & Cross-Validation

Group K-Fold cross-validator.

Guarantees that no group appears in both the train and the test set of a split. Without shuffling, groups are assigned largest first to the fold that currently holds the fewest samples (the same greedy rule as scikit-learn), so fold sizes stay as balanced as the group sizes allow. With shuffle, the groups are permuted and cut into nSplits chunks of nearly equal group count. Train and test indices are returned in ascending order.

Shuffle-Group(s)-Out cross-validation iterator.

Provides randomized train/test indices to split data by groups. Ensures that the same group is not in both test and train sets. testSize and trainSize count groups, not samples: fractions are taken of the number of distinct groups, integers are absolute group counts. With neither given, 20% of the groups form the test set. Train and test indices are returned in ascending order. Iteration i shuffles with a seed derived from randomState and i (a hash, so that neighbouring seeds do not share iterations).

K-Folds cross-validator.

Splits the samples into nSplits consecutive folds (the first n % nSplits folds hold one extra sample). Each fold is used once as the test set while the remaining folds form the train set. Train and test indices are always returned in ascending order, also when shuffle is enabled.

Leave-One-Group-Out cross-validator.

Each distinct group is used once as the test set, in ascending order of the group labels, and the other groups form the train set. At least two groups are required. Train and test indices are returned in ascending order.

Leave-One-Out cross-validator.

Each sample is used once as a test set of size one. This materialises n * (n - 1) train indices, so very large n is rejected with a MemoryError.

Leave-P-Groups-Out cross-validator.

Every combination of nGroups distinct groups is used once as the test set, in lexicographic order of the ascending group labels. The number of splits is C(g, nGroups) for g distinct groups, so the splits are only materialised when they number at most 100,000 and their indices fit a memory budget. Train and test indices are returned in ascending order.

Leave-P-Out cross-validator.

Every combination of p samples is used once as the test set. The number of splits is C(n, p), so the splits are only materialised when they number at most 100,000 and their indices fit a memory budget.

Predefined split cross-validator.

testFold[i] names the fold in which sample i is a test sample. Samples with testFold[i] === -1 are never part of a test set (they are always in the train set). One split is produced for each distinct fold value other than -1, in ascending order.

Repeated K-Fold cross-validator.

Repeats K-Fold nRepeats times with different shuffling in each repetition. With a randomState, repetition r shuffles with a seed derived from randomState and r (a hash, so that neighbouring seeds do not share repetitions).

Repeated Stratified K-Fold cross-validator.

Repeats Stratified K-Fold nRepeats times with different shuffling. With a randomState, repetition r shuffles with a seed derived from randomState and r (a hash, so that neighbouring seeds do not share repetitions).

Random permutation cross-validator.

Yields indices to split data into train and test sets using random permutations. Unlike KFold, ShuffleSplit allows controlling the train/test size independently and produces overlapping test sets across iterations. With neither trainSize nor testSize given, the test set gets 10% of the samples (scikit-learn's default for this splitter). Iteration i shuffles with a seed derived from randomState and i (a hash, so that neighbouring seeds do not share iterations).

Stratified Group K-Fold cross-validator.

Keeps every group in a single fold (like GroupKFold) while trying to keep the class distribution of each fold close to the overall one (like StratifiedKFold). Without shuffling it follows scikit-learn's greedy algorithm: groups are visited from the most to the least unevenly distributed over classes and each goes to the fold whose class proportions end up most even, ties going to the fold with fewer samples. The result is deterministic and matches scikit-learn. With shuffle, the groups are visited in a random order before that sort, so equally uneven groups are placed in a seeded random order (scikit-learn's shuffled folds depend on NumPy's generator and are not reproduced). Train and test indices are returned in ascending order.

Stratified K-Folds cross-validator.

Every fold keeps (as closely as possible) the class proportions of the full data set, and fold sizes differ by at most one sample. Without shuffling the assignment is identical to scikit-learn's StratifiedKFold. Each class must have at least nSplits samples. Train and test indices are returned in ascending order.

Stratified ShuffleSplit cross-validator.

Provides train/test indices that preserve the percentage of samples for each class. Like ShuffleSplit but with stratification: every split contains exactly the requested number of train and test samples, divided among the classes by largest remainder rounding. Every class needs at least 2 samples, and both sets must be at least as large as the number of classes. With neither trainSize nor testSize given, the test set gets 10% of the samples. Iteration i shuffles with a seed derived from randomState and i (a hash, so that neighbouring seeds do not share iterations).

Time Series cross-validator.

Provides train/test indices for time series data. In each split, test indices must be higher than before, and thus shuffling in cross validator is inappropriate. The test sets are the last nSplits blocks of testSize samples; each train set is everything before its test block, minus gap samples, optionally capped to the most recent maxTrainSize samples.