-i, SrSSKrSSKrSSKJrJr SSKJr SSKJ r SSK J r SSK J r Jr SSKJrJr SSKrSS KJr S S KJrJrJrJr S S KJrJrJr S S KJ r J!r!J"r" S SK#J$r$ S SK%J&r& S SK'J(r( S SK)J*r*J+r+J,r, /SQr-"SS5r."SS\&5r/"SS\&\S9r0"SS\.\05r1"SS\.\05r2"SS\0\S9r3"S S!\.\35r4"S"S#\/\35r5"S$S%\35r6"S&S'\/\35r7"S(S)\35r8"S*S+\/\05r9"S,S-\/\05r:"S.S/\&\S9r;"S0S1\.\;5r<"S2S3\.\;5r="S4S5\&\S9r>"S6S7\.\>5r?"S8S9\/\>5r@"S:S;\>5rASSS<jrB"S=S>\05rC"S?S@\05rDSTSASB.SCjjrE\""\ "\!SSDSESF9\ "\RSDSSGSF9S/\ "\!SSDSESF9\ "\RSDSSGSF9S/SH/SI/SJS/SK.SLSM9SSSSLSSK.SNj5rG\H"\GSOSA5 S\I4SPjrJSQrKSRrLg)Uz The :mod:`sklearn.model_selection._split` module includes classes and functions to split the data based on a preset strategy. N)ABCMetaabstractmethod) defaultdict)Iterable) signature)chain combinations)ceilfloor)comb)_safe_indexingcheck_random_state indexablemetadata_routing)_convert_to_numpyensure_common_namespace_device get_namespace)Interval RealNotIntvalidate_params)_approximate_mode)_MetadataRequester)type_of_target) _num_samples check_array column_or_1d)BaseCrossValidator GroupKFoldGroupShuffleSplitKFoldLeaveOneGroupOut LeaveOneOutLeavePGroupsOut LeavePOutPredefinedSplit RepeatedKFoldRepeatedStratifiedKFold ShuffleSplitStratifiedGroupKFoldStratifiedKFoldStratifiedShuffleSplitcheck_cvtrain_test_splitc0^\rSrSrSrSU4SjjrSrU=r$)_UnsupportedGroupCVMixin;z/Mixin for splitters that do not support Groups.c>Ub2[R"SURR3[5 [ TU]XUS9$)aGenerate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) The target variable for supervised learning problems. groups : object Always ignored, exists for compatibility. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. #The groups parameter is ignored by groups)warningswarn __class____name__ UserWarningsupersplitselfXyr5r8s Q/var/www/html/venv/lib/python3.13/site-packages/sklearn/model_selection/_split.pyr<_UnsupportedGroupCVMixin.split>sD.   MM5dnn6M6M5NO w}Q&}11NN)r9 __module__ __qualname____firstlineno____doc__r<__static_attributes__ __classcell__r8s@rAr0r0;s922rCr0c \rSrSrSrSS0rSrg)GroupsConsumerMixin]zA Mixin to ``groups`` by default. This Mixin makes the object to request ``groups`` by default as ``True``. .. versionadded:: 1.3 r5TrDN)r9rFrGrHrI-_GroupsConsumerMixin__metadata_request__splitrJrDrCrArNrN]s"*4 0rCrNcl\rSrSrSrS\R 0rS SjrS Sjr S Sjr \ S Sj5r S r S rg) rhznBase class for all cross-validators. Implementations must define `_iter_test_masks` or `_iter_test_indices`. r5Nc## [XU5upn[R"[U55nUR XU5H%nU[R "U5nXEnXe4v M' g7f)alGenerate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) The target variable for supervised learning problems. groups : array-like of shape (n_samples,), default=None Group labels for the samples used while splitting the dataset into train/test set. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. N)rnparanger_iter_test_masks logical_not)r>r?r@r5indices test_index train_indexs rAr<BaseCrossValidator.splittsd0!v. f))LO,//f=J!".."<=K ,J) )>sA+A-c## URXU5H-n[R"[U5[S9nSXT'Uv M/ g7f)zoGenerates boolean masks corresponding to test sets. By default, delegates to _iter_test_indices(X, y, groups) dtypeTN)_iter_test_indicesrTzerosrbool)r>r?r@r5rY test_masks rArV#BaseCrossValidator._iter_test_maskss@ 11!?Ja=I$(I !O@sAAc[e)z5Generates integer indices corresponding to test sets.)NotImplementedErrorr>r?r@r5s rAr_%BaseCrossValidator._iter_test_indicess!!rCcg)zBReturns the number of splitting iterations in the cross-validator.NrDrfs rA get_n_splitsBaseCrossValidator.get_n_splitssrCc[U5$N _build_reprr>s rA__repr__BaseCrossValidator.__repr__ 4  rCrDrENNN)r9rFrGrHrIrUNUSED,_BaseCrossValidator__metadata_request__splitr<rVr_rrirprJrDrCrArrhsF"*+;+B+B C*B"QQ!rCr) metaclassc,\rSrSrSrSSjrSSjrSrg)r#a(Leave-One-Out cross-validator. Provides train/test indices to split data in train/test sets. Each sample is used once as a test set (singleton) while the remaining samples form the training set. Note: ``LeaveOneOut()`` is equivalent to ``KFold(n_splits=n)`` and ``LeavePOut(p=1)`` where ``n`` is the number of samples. Due to the high number of test sets (which is the same as the number of samples) this cross-validation method can be very costly. For large datasets one should favor :class:`KFold`, :class:`ShuffleSplit` or :class:`StratifiedKFold`. Read more in the :ref:`User Guide `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import LeaveOneOut >>> X = np.array([[1, 2], [3, 4]]) >>> y = np.array([1, 2]) >>> loo = LeaveOneOut() >>> loo.get_n_splits(X) 2 >>> print(loo) LeaveOneOut() >>> for i, (train_index, test_index) in enumerate(loo.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[1] Test: index=[0] Fold 1: Train: index=[0] Test: index=[1] See Also -------- LeaveOneGroupOut : For splitting the data according to explicit, domain-specific stratification of the dataset. GroupKFold : K-fold iterator variant with non-overlapping groups. Ncn[U5nUS::a[SRU55e[U5$)Nz-Cannot perform LeaveOneOut with n_samples={}.)r ValueErrorformatrange)r>r?r@r5 n_sampless rAr_LeaveOneOut._iter_test_indicess: O >?FFyQ YrCc4Uc [S5e[U5$)aReturns the number of splitting iterations in the cross-validator. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : object Always ignored, exists for compatibility. groups : object Always ignored, exists for compatibility. Returns ------- n_splits : int Returns the number of splitting iterations in the cross-validator. %The 'X' parameter should not be None.)r{rrfs rAriLeaveOneOut.get_n_splitss( 9DE EArCrDrE)r9rFrGrHrIr_rirJrDrCrAr#r#s+Z rCr#c2\rSrSrSrSrSSjrSSjrSrg) r%aLeave-P-Out cross-validator. Provides train/test indices to split data in train/test sets. This results in testing on all distinct samples of size p, while the remaining n - p samples form the training set in each iteration. Note: ``LeavePOut(p)`` is NOT equivalent to ``KFold(n_splits=n_samples // p)`` which creates non-overlapping test sets. Due to the high number of iterations which grows combinatorically with the number of samples this cross-validation method can be very costly. For large datasets one should favor :class:`KFold`, :class:`StratifiedKFold` or :class:`ShuffleSplit`. Read more in the :ref:`User Guide `. Parameters ---------- p : int Size of the test sets. Must be strictly less than the number of samples. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import LeavePOut >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 3, 4]) >>> lpo = LeavePOut(2) >>> lpo.get_n_splits(X) 6 >>> print(lpo) LeavePOut(p=2) >>> for i, (train_index, test_index) in enumerate(lpo.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[2 3] Test: index=[0 1] Fold 1: Train: index=[1 3] Test: index=[0 2] Fold 2: Train: index=[1 2] Test: index=[0 3] Fold 3: Train: index=[0 3] Test: index=[1 2] Fold 4: Train: index=[0 2] Test: index=[1 3] Fold 5: Train: index=[0 1] Test: index=[2 3] cXlgrlp)r>rs rA__init__LeavePOut.__init__4srCNc## [U5nX@R::a%[SRURU55e[ [ U5UR5Hn[ R"U5v M g7f)Nz8p={} must be strictly less than the number of samples={})rrr{r|r r}rTarray)r>r?r@r5r~ combinations rAr_LeavePOut._iter_test_indices7sh O  JQQFFI  (i(8$&&AK((;' 'BsA?BclUc [S5e[[[U5URSS95$)aqReturns the number of splitting iterations in the cross-validator. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : object Always ignored, exists for compatibility. groups : object Always ignored, exists for compatibility. rTexact)r{intr rrrfs rAriLeavePOut.get_n_splitsBs1 9DE E4 Qt<==rCrrE) r9rFrGrHrIrr_rirJrDrCrAr%r%s7r (>rCr%cJ^\rSrSrSr\S5rSU4SjjrSSjrSr U=r $) _BaseKFoldiVz;Base class for K-Fold cross-validators and TimeSeriesSplit.c~[U[R5(d[SU<S[ U5<S35e[ U5nUS::a[SR U55e[U[5(d[SR U55eU(dUb [S5eXl X l X0l g)Nz.The number of folds must be of Integral type. z of type z was passed.rzzok-fold cross-validation requires at least one train/test split by setting n_splits=2 or more, got n_splits={0}.z&shuffle must be True or False; got {0}zSetting a random_state has no effect since shuffle is False. You should leave random_state to its default (None), or set shuffle=True.) isinstancenumbersIntegralr{typerr|ra TypeErrorn_splitsshuffle random_state)r>rrrs rAr_BaseKFold.__init__Ys(G$4$455/7hI x= q=%%+VH%5  '4((DKKGTU U<3O !  (rCc#># [XU5upn[U5nURU:a%[SR URU55e[ TU]XU5H upVXV4v M g7f)azGenerate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,), default=None The target variable for supervised learning problems. groups : array-like of shape (n_samples,), default=None Group labels for the samples used while splitting the dataset into train/test set. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. z\Cannot have number of splits n_splits={0} greater than the number of samples: n_samples={1}.N)rrrr{r|r;r<)r>r?r@r5r~traintestr8s rAr<_BaseKFold.splitysq0!v. f O ==9 $B& 2  !7=v6KE+ 7sA/A2cUR$asReturns the number of splitting iterations in the cross-validator. Parameters ---------- X : object Always ignored, exists for compatibility. y : object Always ignored, exists for compatibility. groups : object Always ignored, exists for compatibility. Returns ------- n_splits : int Returns the number of splitting iterations in the cross-validator. rrfs rAri_BaseKFold.get_n_splits&}}rC)rrrrErs) r9rFrGrHrIrrr<rirJrKrLs@rArrVs(E))>#JrCrcD^\rSrSrSrS SSS.U4SjjjrS SjrSrU=r$) r!iaR K-Fold cross-validator. Provides train/test indices to split data in train/test sets. Split dataset into k consecutive folds (without shuffling by default). Each fold is then used once as a validation while the k - 1 remaining folds form the training set. Read more in the :ref:`User Guide `. For visualisation of cross-validation behaviour and comparison between common scikit-learn split methods refer to :ref:`sphx_glr_auto_examples_model_selection_plot_cv_indices.py` Parameters ---------- n_splits : int, default=5 Number of folds. Must be at least 2. .. versionchanged:: 0.22 ``n_splits`` default value changed from 3 to 5. shuffle : bool, default=False Whether to shuffle the data before splitting into batches. Note that the samples within each split will not be shuffled. random_state : int, RandomState instance or None, default=None When `shuffle` is True, `random_state` affects the ordering of the indices, which controls the randomness of each fold. Otherwise, this parameter has no effect. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import KFold >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([1, 2, 3, 4]) >>> kf = KFold(n_splits=2) >>> kf.get_n_splits(X) 2 >>> print(kf) KFold(n_splits=2, random_state=None, shuffle=False) >>> for i, (train_index, test_index) in enumerate(kf.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[2 3] Test: index=[0 1] Fold 1: Train: index=[0 1] Test: index=[2 3] Notes ----- The first ``n_samples % n_splits`` folds have size ``n_samples // n_splits + 1``, other folds have size ``n_samples // n_splits``, where ``n_samples`` is the number of samples. Randomized CV splitters may return different results for each call of split. You can make the results identical by setting `random_state` to an integer. See Also -------- StratifiedKFold : Takes class information into account to avoid building folds with imbalanced class distributions (for binary or multiclass classification tasks). GroupKFold : K-fold iterator variant with non-overlapping groups. RepeatedKFold : Repeats K-Fold n times. FNrrc">[TU]XUS9 gN)rrrr;rr>rrrr8s rArKFold.__init__ (,WrCc#X# [U5n[R"U5nUR(a$[ UR 5RU5 UR n[R"XdU-[S9nUSXF-===S- sss&SnUHn XU -pXZU v U nM g7f)Nr]rzr) rrTrUrrrrfullr) r>r?r@r5r~rXr fold_sizescurrent fold_sizestartstops rAr_KFold._iter_test_indicess O ))I& << t00 1 9 9' B==WWXH'`. For visualisation of cross-validation behaviour and comparison between common scikit-learn split methods refer to :ref:`sphx_glr_auto_examples_model_selection_plot_cv_indices.py` Parameters ---------- n_splits : int, default=5 Number of folds. Must be at least 2. .. versionchanged:: 0.22 ``n_splits`` default value changed from 3 to 5. shuffle : bool, default=False Whether to shuffle the groups before splitting into batches. Note that the samples within each split will not be shuffled. .. versionadded:: 1.6 random_state : int, RandomState instance or None, default=None When `shuffle` is True, `random_state` affects the ordering of the indices, which controls the randomness of each fold. Otherwise, this parameter has no effect. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. .. versionadded:: 1.6 Notes ----- Groups appear in an arbitrary order throughout the folds. Examples -------- >>> 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([0, 0, 2, 2, 3, 3]) >>> group_kfold = GroupKFold(n_splits=2) >>> group_kfold.get_n_splits(X, y, groups) 2 >>> print(group_kfold) GroupKFold(n_splits=2, random_state=None, shuffle=False) >>> for i, (train_index, test_index) in enumerate(group_kfold.split(X, y, groups)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}, group={groups[train_index]}") ... print(f" Test: index={test_index}, group={groups[test_index]}") Fold 0: Train: index=[2 3], group=[2 2] Test: index=[0 1 4 5], group=[0 0 3 3] Fold 1: Train: index=[0 1 4 5], group=[0 0 3 3] Test: index=[2 3], group=[2 2] See Also -------- LeaveOneGroupOut : For splitting the data according to explicit domain-specific stratification of the dataset. StratifiedKFold : Takes class information into account to avoid building folds with imbalanced class proportions (for binary or multiclass classification tasks). FNrc">[TU]XUS9 g)Nrrrs rArGroupKFold.__init___s NrCc## Uc [S5e[USSSS9n[R"USS9upE[ U5nUR U:a[SUR U4-5eUR (a[UR5nURU5n[R"X@R 5nUH4n [R"X95n [R"U 5Sv M6 g[R"U5n [R"U 5SSS 2n Xn [R"UR 5n [R"[ U55n[!U 5H0unn[R""U 5nU U==U- ss'UXU'M2 Xn [%UR 5H!n[R"U U:H5Sv M# g7f) N*The 'groups' parameter should not be None.r5F input_name ensure_2dr^Treturn_inversezOCannot have number of splits n_splits=%d greater than the number of groups: %d.r)r{rrTuniquelenrrrr permutation array_splitisinwherebincountargsortr` enumerateargminr})r>r?r@r5 unique_groups group_idxn_groupsrng split_groupstest_group_idsrbn_samples_per_grouprXn_samples_per_fold group_to_fold group_indexweight lightest_foldfs rAr_GroupKFold._iter_test_indicesbs >IJ JVEQUV#%99VD#I }% ==8 #259]]H4MN  <<$T%6%67COOM:M>>-GL".GGF; hhy)!,,#/ #%++i"8 jj!45dd;G"5"> "$$--!8 HHS%78M(11D'E# V " *< = "=1V;16C k23(F $.G4==)hhw!|,Q//*sG,G.c$>[TU]XU5$alGenerate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,), default=None The target variable for supervised learning problems. groups : array-like of shape (n_samples,) Group labels for the samples used while splitting the dataset into train/test set. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. r;r<r=s rAr<GroupKFold.split0w}Q6**rCrDrrE) r9rFrGrHrIrr_r<rJrKrLs@rArrs0HTOe$OO/0b++rCrc^^\rSrSrSrS SSS.U4SjjjrS SjrS SjrS U4S jjrS r U=r $)r+ia Class-wise stratified K-Fold cross-validator. Provides train/test indices to split data in train/test sets. This cross-validation object is a variation of KFold that returns stratified folds. The folds are made by preserving the percentage of samples for each class in `y` in a binary or multiclass classification setting. Read more in the :ref:`User Guide `. For visualisation of cross-validation behaviour and comparison between common scikit-learn split methods refer to :ref:`sphx_glr_auto_examples_model_selection_plot_cv_indices.py` .. note:: Stratification on the class label solves an engineering problem rather than a statistical one. See :ref:`stratification` for more details. Parameters ---------- n_splits : int, default=5 Number of folds. Must be at least 2. .. versionchanged:: 0.22 ``n_splits`` default value changed from 3 to 5. shuffle : bool, default=False Whether to shuffle each class's samples before splitting into batches. Note that the samples within each split will not be shuffled. random_state : int, RandomState instance or None, default=None When `shuffle` is True, `random_state` affects the ordering of the indices, which controls the randomness of each fold for each class. Otherwise, leave `random_state` as `None`. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import StratifiedKFold >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> skf = StratifiedKFold(n_splits=2) >>> skf.get_n_splits(X, y) 2 >>> print(skf) StratifiedKFold(n_splits=2, random_state=None, shuffle=False) >>> for i, (train_index, test_index) in enumerate(skf.split(X, y)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[1 3] Test: index=[0 2] Fold 1: Train: index=[0 2] Test: index=[1 3] Notes ----- The implementation is designed to: * Generate test sets such that all contain the same distribution of classes, or as close as possible. * Be invariant to class label: relabelling ``y = ["Happy", "Sad"]`` to ``y = [1, 0]`` should not change the indices generated. * Preserve order dependencies in the dataset ordering, when ``shuffle=False``: all samples from class k in some test set were contiguous in y, or separated in y by samples from classes other than k. * Generate test sets where the smallest and largest differ by at most one sample. .. versionchanged:: 0.22 The previous implementation did not follow the last constraint. See Also -------- RepeatedStratifiedKFold : Repeats Stratified K-Fold n times. FNrc">[TU]XUS9 grrrs rArStratifiedKFold.__init__rrCc [UR5n[U5upEU(a [X$5nO[R "U5n[ U5nSnXg;a[SRXv55e[U5n[R"USSS9upn [R"U SS9upXn [U 5n [R"U 5n[R"U5n[R"URU:5(a[SUR-5eURU:a)[ R""SXR4-[$5 [R&"U 5n[R "[)UR5Vs/sH(n[R"UUSUR2U S9PM* sn5n[R*"[U5S S 9n[)U 5Hcn[R,"UR5R/USS2U45nUR0(aUR1U5 UUU U:H'Me U$s snf) Nbinary multiclass1Supported target types are: {}. Got {!r} instead.T) return_indexrrGn_splits=%d cannot be greater than the number of members in each class.SThe least populated class in y has only %d members, which is less than n_splits=%d.) minlengthir])rrrrrTasarrayrr{r|rrrrminallrr6r7r:sortr}emptyrUrepeatr)r>r?r@rxp is_array_apitype_of_target_yallowed_target_types_y_idxy_inv class_perm y_encoded n_classesy_counts min_groupsy_orderr allocation test_foldskfolds_for_classs rA_make_test_folds StratifiedKFold._make_test_foldss !2!23 )+ !!(A 1 A)!,7  7CJJ(  O))ADN% %= % J ;;y)VVH% 66$--(* + +47;}}F  ==: % MM<}}-.  '')$ZZt}}- -A GA$6$679M-  XXc!fC0 y!A!ii 6==jA>NOO|| O,)8JyA~ &"% s$/I,c#r# URX5n[UR5H nXE:Hv M g7frl)rr}r)r>r?r@r5rrs rArV StratifiedKFold._iter_test_masksKs0**10 t}}%A/ !&s57c>Ub2[R"SURR3[5 [ USSSS9n[ TU]XU5$)Generate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. Note that providing ``y`` is sufficient to generate the splits and hence ``np.zeros(n_samples)`` may be used as a placeholder for ``X`` instead of actual training data. y : array-like of shape (n_samples,) The target variable for supervised learning problems. Stratification is done based on the y labels. groups : object Always ignored, exists for compatibility. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. Notes ----- Randomized CV splitters may return different results for each call of split. You can make the results identical by setting `random_state` to an integer. Nr3r@Frr6r7r8r9r:rr;r<r=s rAr<StratifiedKFold.splitPSD   MM5dnn6M6M5NO  cU$ Gw}Q6**rCrDrrlrE) r9rFrGrHrIrrrVr<rJrKrLs@rAr+r+s6QfXe$XXDL" (+(+rCr+c<^\rSrSrSrSU4SjjrSrSrSrU=r $)r*i{aClass-wise stratified K-Fold iterator variant with non-overlapping groups. This cross-validation object is a variation of StratifiedKFold attempts to return stratified folds with non-overlapping groups. The folds are made by preserving the percentage of samples for each class in `y` in a binary or multiclass classification setting. Each group will appear exactly once in the test set across all folds (the number of distinct groups has to be at least equal to the number of folds). The difference between :class:`GroupKFold` and `StratifiedGroupKFold` is that the former attempts to create balanced folds such that the number of distinct groups is approximately the same in each fold, whereas `StratifiedGroupKFold` attempts to create folds which preserve the percentage of samples for each class as much as possible given the constraint of non-overlapping groups between splits. Read more in the :ref:`User Guide `. For visualisation of cross-validation behaviour and comparison between common scikit-learn split methods refer to :ref:`sphx_glr_auto_examples_model_selection_plot_cv_indices.py` .. note:: Stratification on the class label solves an engineering problem rather than a statistical one. See :ref:`stratification` for more details. Parameters ---------- n_splits : int, default=5 Number of folds. Must be at least 2. shuffle : bool, default=False Whether to shuffle each class's samples before splitting into batches. Note that the samples within each split will not be shuffled. This implementation can only shuffle groups that have approximately the same y distribution, no global shuffle will be performed. random_state : int or RandomState instance, default=None When `shuffle` is True, `random_state` affects the ordering of the indices, which controls the randomness of each fold for each class. Otherwise, leave `random_state` as `None`. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import StratifiedGroupKFold >>> X = np.ones((17, 2)) >>> y = np.array([0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]) >>> groups = np.array([1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8]) >>> sgkf = StratifiedGroupKFold(n_splits=3) >>> sgkf.get_n_splits(X, y) 3 >>> print(sgkf) StratifiedGroupKFold(n_splits=3, random_state=None, shuffle=False) >>> for i, (train_index, test_index) in enumerate(sgkf.split(X, y, groups)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" group={groups[train_index]}") ... print(f" Test: index={test_index}") ... print(f" group={groups[test_index]}") Fold 0: Train: index=[ 0 1 2 3 7 8 9 10 11 15 16] group=[1 1 2 2 4 5 5 5 5 8 8] Test: index=[ 4 5 6 12 13 14] group=[3 3 3 6 6 7] Fold 1: Train: index=[ 4 5 6 7 8 9 10 11 12 13 14] group=[3 3 3 4 5 5 5 5 6 6 7] Test: index=[ 0 1 2 3 15 16] group=[1 1 2 2 8 8] Fold 2: Train: index=[ 0 1 2 3 4 5 6 12 13 14 15 16] group=[1 1 2 2 3 3 3 6 6 7 8 8] Test: index=[ 7 8 9 10 11] group=[4 5 5 5 5] Notes ----- The implementation is designed to: * Mimic the behavior of StratifiedKFold as much as possible for trivial groups (e.g. when each group contains only one sample). * Be invariant to class label: relabelling ``y = ["Happy", "Sad"]`` to ``y = [1, 0]`` should not change the indices generated. * Stratify based on samples as much as possible while keeping non-overlapping groups constraint. That means that in some cases when there is a small number of groups containing a large number of samples the stratification will not be possible and the behavior will be close to GroupKFold. See also -------- StratifiedKFold: Takes class information into account to build folds which retain class distributions (for binary or multiclass classification tasks). GroupKFold: K-fold iterator variant with non-overlapping groups. c">[TU]XUS9 grrrs rArStratifiedGroupKFold.__init__rrCc# # [UR5n[R"U5n[ U5nSnXV;a[ SR Xe55e[U5n[R"USSS9upxn [R"URU :5(a[ SUR-5e[R"U 5n URU :a)[R"SXR4-[5 [U 5n [R"USSS9up|n [R "[U 5U 45n[#X5HunnUUU4==S- ss'M [R "URU 45n[%[&5nUR((aUR)U5 [R*"[R,"USS9*S S 9nUH:nUUnUR/UU US 9nUU==U- ss'UUR1U5 M< [3UR5H2n[5U 5VVs/sHunnUUU;dMUPM nnnUv M4 gs snnf7f) NrrT)r return_countsrrrzaxis mergesortkind)y_counts_per_foldy_cntgroup_y_counts)rrrTrrr{r|rrrrrr6r7r:rr`ziprsetrrstd_find_best_foldaddr}r)r>r?r@r5rrrrrrn_smallest_classr groups_inv groups_cnty_counts_per_group class_idxrrgroups_per_foldsorted_groups_idxr best_foldridx test_indicess rAr_'StratifiedGroupKFold._iter_test_indicessk !!2!23 JJqM)!,7  7CJJ(  O))Ad$O% 66$--%' ( (47;}}F 66%= ==+ + MM<#]]34   J $&II 4t% !z XXs: &BC$'$: Iy y)3 4 9 4%;HHdmmY%?@%c* << KK* +JJ VV&Q / /k +I/ :N,,"3--I i (N : ( I & * *9 5+t}}%A'0 &;&;NC 22&;    &sIJI>,I>2JcSn[Rn[Rn[UR5HnX==U- ss'[R"XR SS5- SS9nX==U-ss'[R "U5n [R"X5n X:=(d! [R"X5=(a X:n U (dMU nU nUnM U$)Nrzrrr) rTinfr}rrreshapemeansumisclose) r>rrrr(min_evalmin_samples_in_foldr std_per_class fold_evalsamples_in_foldis_current_fold_betters rAr$StratifiedGroupKFold._find_best_fold8s 66 fft}}%A  N 2 FF#4}}Q7K#KRSTM  N 2  .I ff%6%9:O%.%9& 9/:#9 #&%$&5# &rCrD)rFN) r9rFrGrHrIrr_rrJrKrLs@rAr*r*{s!fPXObrCr*cL^\rSrSrSrS SSSS.U4SjjjrS SjrSrS rU=r $) TimeSeriesSplitiNaTime Series cross-validator. Provides train/test indices to split time-ordered data, where other cross-validation methods are inappropriate, as they would lead to training on future data and evaluating on past data. To ensure comparable metrics across folds, samples must be equally spaced. Once this condition is met, each test set covers the same time duration, while the train set size accumulates data from previous splits. This cross-validation object is a variation of :class:`KFold`. In the k-th split, it returns the first k folds as the train set and the (k+1)-th fold as the test set. Note that, unlike standard cross-validation methods, successive training sets are supersets of those that come before them. Read more in the :ref:`User Guide `. For visualisation of cross-validation behaviour and comparison between common scikit-learn split methods refer to :ref:`sphx_glr_auto_examples_model_selection_plot_cv_indices.py` .. versionadded:: 0.18 Parameters ---------- n_splits : int, default=5 Number of splits. Must be at least 2. .. versionchanged:: 0.22 ``n_splits`` default value changed from 3 to 5. max_train_size : int, default=None Maximum size for a single training set. test_size : int, default=None Used to limit the size of the test set. Defaults to ``n_samples // (n_splits + 1)``, which is the maximum allowed value with ``gap=0``. .. versionadded:: 0.24 gap : int, default=0 Number of samples to exclude from the end of each train set before the test set. .. versionadded:: 0.24 Examples -------- >>> import numpy as np >>> 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() >>> print(tscv) TimeSeriesSplit(gap=0, max_train_size=None, n_splits=5, test_size=None) >>> for i, (train_index, test_index) in enumerate(tscv.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[0] Test: index=[1] Fold 1: Train: index=[0 1] Test: index=[2] Fold 2: Train: index=[0 1 2] Test: index=[3] Fold 3: Train: index=[0 1 2 3] Test: index=[4] Fold 4: Train: index=[0 1 2 3 4] Test: index=[5] >>> # Fix test_size to 2 with 12 samples >>> X = np.random.randn(12, 2) >>> y = np.random.randint(0, 2, 12) >>> tscv = TimeSeriesSplit(n_splits=3, test_size=2) >>> for i, (train_index, test_index) in enumerate(tscv.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[0 1 2 3 4 5] Test: index=[6 7] Fold 1: Train: index=[0 1 2 3 4 5 6 7] Test: index=[8 9] Fold 2: Train: index=[0 1 2 3 4 5 6 7 8 9] Test: index=[10 11] >>> # Add in a 2 period gap >>> tscv = TimeSeriesSplit(n_splits=3, test_size=2, gap=2) >>> for i, (train_index, test_index) in enumerate(tscv.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[0 1 2 3] Test: index=[6 7] Fold 1: Train: index=[0 1 2 3 4 5] Test: index=[8 9] Fold 2: Train: index=[0 1 2 3 4 5 6 7] Test: index=[10 11] For a more extended example see :ref:`sphx_glr_auto_examples_applications_plot_cyclical_feature_engineering.py`. Notes ----- The training set has size ``i * n_samples // (n_splits + 1) + n_samples % (n_splits + 1)`` in the ``i`` th split, with a test set of size ``n_samples//(n_splits + 1)`` by default, where ``n_samples`` is the number of samples. Note that this formula is only valid when ``test_size`` and ``max_train_size`` are left to their default values. Nr)max_train_size test_sizegapcH>[TU]USSS9 X lX0lX@lg)NFr)r;rr;r<r=)r>rr;r<r=r8s rArTimeSeriesSplit.__init__s' 5tD,"rCcUb2[R"SURR3[5 UR U5$)a%Generate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Always ignored, exists for compatibility. groups : array-like of shape (n_samples,) Always ignored, exists for compatibility. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. r3r6r7r8r9r:_splitrfs rAr<TimeSeriesSplit.splits>.   MM5dnn6M6M5NO {{1~rCc #"# [U5un[U5nURnUS-nURnURb UROX$-nXB:a[ SUSUS35eX%- Xc-- S::a[ SUSUS US US3 5e[ R"U5n[X#U-- X&5nUHPn X- n UR(a+URU :aXzUR- U XyX-4v MCUSU XyX-4v MR g7f) axGenerate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. rzNzCannot have number of folds=z$ greater than the number of samples=.rzToo many splits=z for number of samples=z with test_size=z and gap=) rrrr=r<r{rTrUr}r;) r>r?r~rn_foldsr=r<rX test_starts test_start train_ends rArBTimeSeriesSplit._splitsY"| O ==Q,hh"nn8DNNi>R   .wi8//8k<  ?i2 3q 8"8*-;.yk3%qJ  ))I&I9(<`. Notes ----- Splits are ordered according to the index of the group left out. The first split has testing set consisting of the group whose index in `groups` is lowest, and so on. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import LeaveOneGroupOut >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 1, 2]) >>> groups = np.array([1, 1, 2, 2]) >>> logo = LeaveOneGroupOut() >>> logo.get_n_splits(X, y, groups) 2 >>> logo.get_n_splits(groups=groups) # 'groups' is always required 2 >>> print(logo) LeaveOneGroupOut() >>> for i, (train_index, test_index) in enumerate(logo.split(X, y, groups)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}, group={groups[train_index]}") ... print(f" Test: index={test_index}, group={groups[test_index]}") Fold 0: Train: index=[2 3], group=[2 2] Test: index=[0 1], group=[1 1] Fold 1: Train: index=[0 1], group=[1 1] Test: index=[2 3], group=[2 2] See also -------- GroupKFold: K-fold iterator variant with non-overlapping groups. c## Uc [S5e[USSSSS9n[R"U5n[ U5S::a[SU-5eUH nX5:Hv M g7f)Nrr5TFrcopyrr^rzzcThe groups parameter contains fewer than 2 unique groups (%s). LeaveOneGroupOut expects at least 2.)r{rrTrr)r>r?r@r5rrs rArV!LeaveOneGroupOut._iter_test_masksUsw >IJ J xde4  &) }  "=?LM A+ sAA!ctUc [S5e[USSSS9n[[R"U55$)BReturns the number of splitting iterations in the cross-validator. Parameters ---------- X : object Always ignored, exists for compatibility. y : object Always ignored, exists for compatibility. groups : array-like of shape (n_samples,) Group labels for the samples used while splitting the dataset into train/test set. This 'groups' parameter must always be specified to calculate the number of splits, though the other parameters can be omitted. Returns ------- n_splits : int Returns the number of splitting iterations in the cross-validator. Nrr5Fr)r{rrrTrrfs rAriLeaveOneGroupOut.get_n_splitses:, >IJ JVEQUV299V$%%rCc$>[TU]XU5$rrr=s rAr<LeaveOneGroupOut.splitrrCrDrsrE) r9rFrGrHrIrVrir<rJrKrLs@rAr"r"$s.` &6++rCr"cF^\rSrSrSrSrSrSSjrS U4SjjrSr U=r $) r$iaLeave P Group(s) Out cross-validator. Provides train/test indices to split data according to a third-party provided group. This group information can be used to encode arbitrary domain specific stratifications of the samples as integers. For instance the groups could be the year of collection of the samples and thus allow for cross-validation against time-based splits. The difference between LeavePGroupsOut and LeaveOneGroupOut is that the former builds the test sets with all the samples assigned to ``p`` different values of the groups while the latter uses samples all assigned the same groups. Read more in the :ref:`User Guide `. Parameters ---------- n_groups : int Number of groups (``p``) to leave out in the test split. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import LeavePGroupsOut >>> X = np.array([[1, 2], [3, 4], [5, 6]]) >>> y = np.array([1, 2, 1]) >>> groups = np.array([1, 2, 3]) >>> lpgo = LeavePGroupsOut(n_groups=2) >>> lpgo.get_n_splits(X, y, groups) 3 >>> lpgo.get_n_splits(groups=groups) # 'groups' is always required 3 >>> print(lpgo) LeavePGroupsOut(n_groups=2) >>> for i, (train_index, test_index) in enumerate(lpgo.split(X, y, groups)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}, group={groups[train_index]}") ... print(f" Test: index={test_index}, group={groups[test_index]}") Fold 0: Train: index=[2], group=[3] Test: index=[0 1], group=[1 2] Fold 1: Train: index=[1], group=[2] Test: index=[0 2], group=[1 3] Fold 2: Train: index=[0], group=[1] Test: index=[1 2], group=[2 3] See Also -------- GroupKFold : K-fold iterator variant with non-overlapping groups. cXlgrlr)r>rs rArLeavePGroupsOut.__init__s rCc## Uc [S5e[USSSSS9n[R"U5nUR[ U5:a'[SURX@RS-4-5e[ [[ U55UR5nUHPn[R"[U5[S9nU[R"U5H nSXsU:H'M Uv MR g7f) Nrr5TFrMzThe groups parameter contains fewer than (or equal to) n_groups (%d) numbers of unique groups (%s). LeavePGroupsOut expects that at least n_groups + 1 (%d) unique groups be presentrzr]) r{rrTrrrr r}r`rrar) r>r?r@r5rcombirXrYls rArV LeavePGroupsOut._iter_test_maskss >IJ J xde4  &) ==C . ."]]M==1;LMN  U3}#56 FG,q/>J"288G#45*. Q;'6  sC1C3c Uc [S5e[USSSS9n[[[ [ R "U55URSS95$)rQNrr5FrTr)r{rrr rrTrrrfs rAriLeavePGroupsOut.get_n_splitssL, >IJ JVEQUV4BIIf-. TJKKrCc$>[TU]XU5$rrr=s rAr<LeavePGroupsOut.splitrrCrWrsrE) r9rFrGrHrIrrVrir<rJrKrLs@rAr$r$s#4l!*L6++rCr$c^\rSrSrSrS\R 0rSSS.SjrS Sjr S S jr S r S r g)_RepeatedSplitsi aRepeated splits for an arbitrary randomized CV splitter. Repeats splits for cross-validators n times with different randomization in each repetition. Parameters ---------- cv : callable Cross-validator class. n_repeats : int, default=10 Number of times cross-validator needs to be repeated. random_state : int, RandomState instance or None, default=None Passes `random_state` to the arbitrary repeating cross validator. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. **cvargs : additional params Constructor parameters for cv. Must not contain random_state and shuffle. r5 N) n_repeatsrc ^[U[R5(d [S5eUS::a [S5e[ U4SjS55(a [S5eXlX lX0lTUlg)Nz/Number of repetitions must be of Integral type.rz-Number of repetitions must be greater than 0.c3,># UH oT;v M g7frlrD).0keycvargss rA +_RepeatedSplits.__init__..EsD(Cf}(Csrrz0cvargs must not contain random_state or shuffle.) rrrr{anycvrdrri)r>rnrdrris `rAr_RepeatedSplits.__init__>sj)W%5%566NO O >LM M D(CD D DOP P"( rCc## URn[UR5n[U5HBnUR"SUSS.UR D6nUR XU5H upX4v M MD g7f)amGenerates indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) The target variable for supervised learning problems. groups : array-like of shape (n_samples,), default=None Group labels for the samples used while splitting the dataset into train/test set. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. TrlNrD)rdrrr}rnrir<) r>r?r@r5rdrr)rnrZrYs rAr<_RepeatedSplits.splitMsm0NN  !2!23#CGc4G4;;GB+-88A&+A' !--,B$sA4A6c[UR5nUR"SUSS.URD6nUR XU5UR -$)a<Returns the number of splitting iterations in the cross-validator. Parameters ---------- X : object Always ignored, exists for compatibility. ``np.zeros(n_samples)`` may be used as a placeholder. y : object Always ignored, exists for compatibility. ``np.zeros(n_samples)`` may be used as a placeholder. groups : array-like of shape (n_samples,), default=None Group labels for the samples used while splitting the dataset into train/test set. Returns ------- n_splits : int Returns the number of splitting iterations in the cross-validator. TrlrD)rrrnrirird)r>r?r@r5rrns rAri_RepeatedSplits.get_n_splitsmsJ,!!2!23 WW C#t Ct{{ CqV,t~~==rCc[U5$rlrmros rArp_RepeatedSplits.__repr__rrrC)rnrirdrrErs) r9rFrGrHrIrrt(_RepeatedSplits__metadata_request__splitrr<rirprJrDrCrArbrb s56"*+;+B+B C(* .@>4!rCrbc8^\rSrSrSrSSSS.U4SjjrSrU=r$) r'ia3Repeated K-Fold cross validator. Repeats K-Fold `n_repeats` times with different randomization in each repetition. Read more in the :ref:`User Guide `. Parameters ---------- n_splits : int, default=5 Number of folds. Must be at least 2. n_repeats : int, default=10 Number of times cross-validator needs to be repeated. random_state : int, RandomState instance or None, default=None Controls the randomness of each repeated cross-validation instance. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import RepeatedKFold >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> rkf = RepeatedKFold(n_splits=2, n_repeats=2, random_state=2652124) >>> rkf.get_n_splits(X, y) 4 >>> print(rkf) RepeatedKFold(n_repeats=2, n_splits=2, random_state=2652124) >>> for i, (train_index, test_index) in enumerate(rkf.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") ... Fold 0: Train: index=[0 1] Test: index=[2 3] Fold 1: Train: index=[2 3] Test: index=[0 1] Fold 2: Train: index=[1 2] Test: index=[0 3] Fold 3: Train: index=[0 3] Test: index=[1 2] Notes ----- Randomized CV splitters may return different results for each call of split. You can make the results identical by setting `random_state` to an integer. See Also -------- RepeatedStratifiedKFold : Repeats Stratified K-Fold n times. rrcNrrdrc,>[TU][X#US9 gN)rdrr)r;rr!r>rrdrr8s rArRepeatedKFold.__init__s  YH  rCrDr9rFrGrHrIrrJrKrLs@rAr'r's9v$%  rCr'cH^\rSrSrSrSSSS.U4SjjrS U4SjjrS rU=r$) r(iaRepeated class-wise stratified K-Fold cross validator. Repeats Stratified K-Fold n times with different randomization in each repetition. Read more in the :ref:`User Guide `. .. note:: Stratification on the class label solves an engineering problem rather than a statistical one. See :ref:`stratification` for more details. Parameters ---------- n_splits : int, default=5 Number of folds. Must be at least 2. n_repeats : int, default=10 Number of times cross-validator needs to be repeated. random_state : int, RandomState instance or None, default=None Controls the generation of the random states for each repetition. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import RepeatedStratifiedKFold >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> rskf = RepeatedStratifiedKFold(n_splits=2, n_repeats=2, ... random_state=36851234) >>> rskf.get_n_splits(X, y) 4 >>> print(rskf) RepeatedStratifiedKFold(n_repeats=2, n_splits=2, random_state=36851234) >>> for i, (train_index, test_index) in enumerate(rskf.split(X, y)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") ... Fold 0: Train: index=[1 2] Test: index=[0 3] Fold 1: Train: index=[0 3] Test: index=[1 2] Fold 2: Train: index=[1 3] Test: index=[0 2] Fold 3: Train: index=[0 2] Test: index=[1 3] Notes ----- Randomized CV splitters may return different results for each call of split. You can make the results identical by setting `random_state` to an integer. See Also -------- RepeatedKFold : Repeats K-Fold n times. rrcNrxc.>[TU][UUUS9 grz)r;rr+r{s rAr RepeatedStratifiedKFold.__init__s!  %  rCc8>[USSSS9n[TU] XUS9$)r r@FNrr4)rr;r<r=s rAr<RepeatedStratifiedKFold.splits)D cU$ Gw}Q&}11rCrDrl) r9rFrGrHrIrr<rJrKrLs@rAr(r(s'@D$%  #2#2rCr(cp\rSrSrSrS\R 0rS SSSS.SjjrS Sjr S Sjr SS jr S r S r g)BaseShuffleSpliti>a Base class for *ShuffleSplit. Parameters ---------- n_splits : int, default=10 Number of re-shuffling & splitting iterations. test_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split. If int, represents the absolute number of test samples. If None, the value is set to the complement of the train size. If ``train_size`` is also None, it will be set to 0.1. train_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the train split. If int, represents the absolute number of train samples. If None, the value is automatically set to the complement of the test size. random_state : int, RandomState instance or None, default=None Controls the randomness of the training and testing indices produced. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. r5Nr< train_sizercBXlX lX0lX@lSUlg)N皙?)rr<rr_default_test_size)r>rr<rrs rArBaseShuffleSplit.__init___s!! "$("%rCc#j# [XU5upnURXU5H upEXE4v M g7f)aGenerate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) The target variable for supervised learning problems. groups : array-like of shape (n_samples,), default=None Group labels for the samples used while splitting the dataset into train/test set. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. Notes ----- Randomized CV splitters may return different results for each call of split. You can make the results identical by setting `random_state` to an integer. N)r _iter_indicesr>r?r@r5rrs rAr<BaseShuffleSplit.spliths8<!v. f--aF;KE+ r?r@r5r~n_trainn_testrrrind_test ind_trains rArBaseShuffleSplit._iter_indicess O 1  NN OO"55  !!2!23t}}%A//)4K"7F+H#f.>@I% % &sB B cUR$rrrfs rAriBaseShuffleSplit.get_n_splitsrrCc[U5$rlrmros rArpBaseShuffleSplit.__repr__rrrC)rrrr<rrcrErs)r9rFrGrHrIrrt*_BaseShuffleSplit__metadata_request__splitrr<rrirprJrDrCrArr>sF<"*+;+B+B C&(,D& D&$*!rCrc>^\rSrSrSrSSSSS.U4SjjjrSrU=r$)r)ia Random permutation cross-validator. Yields indices to split data into training and test sets. Note: contrary to other cross-validation strategies, random splits do not guarantee that test sets across all folds will be mutually exclusive, and might include overlapping samples. However, this is still very likely for sizeable datasets. Read more in the :ref:`User Guide `. For visualisation of cross-validation behaviour and comparison between common scikit-learn split methods refer to :ref:`sphx_glr_auto_examples_model_selection_plot_cv_indices.py` Parameters ---------- n_splits : int, default=10 Number of re-shuffling & splitting iterations. test_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split. If int, represents the absolute number of test samples. If None, the value is set to the complement of the train size. If ``train_size`` is also None, it will be set to 0.1. train_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the train split. If int, represents the absolute number of train samples. If None, the value is automatically set to the complement of the test size. random_state : int, RandomState instance or None, default=None Controls the randomness of the training and testing indices produced. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import ShuffleSplit >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [3, 4], [5, 6]]) >>> y = np.array([1, 2, 1, 2, 1, 2]) >>> rs = ShuffleSplit(n_splits=5, test_size=.25, random_state=0) >>> rs.get_n_splits(X) 5 >>> print(rs) ShuffleSplit(n_splits=5, random_state=0, test_size=0.25, train_size=None) >>> for i, (train_index, test_index) in enumerate(rs.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[1 3 0 4] Test: index=[5 2] Fold 1: Train: index=[4 0 2 5] Test: index=[1 3] Fold 2: Train: index=[1 2 4 0] Test: index=[3 5] Fold 3: Train: index=[3 4 1 0] Test: index=[5 2] Fold 4: Train: index=[3 5 1 0] Test: index=[2 4] >>> # Specify train and test size >>> rs = ShuffleSplit(n_splits=5, train_size=0.5, test_size=.25, ... random_state=0) >>> for i, (train_index, test_index) in enumerate(rs.split(X)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[1 3 0] Test: index=[5 2] Fold 1: Train: index=[4 0 2] Test: index=[1 3] Fold 2: Train: index=[1 2 4] Test: index=[3 5] Fold 3: Train: index=[3 4 1] Test: index=[5 2] Fold 4: Train: index=[3 5 1] Test: index=[2 4] Nrc4>[TU]UUUUS9 SUlgNrr<rrrr;rrr>rr<rrr8s rArShuffleSplit.__init__- !%  #&rCrrr}rLs@rAr)r)s%Zz &(,D & &rCr)cZ^\rSrSrSrS SSSS.U4SjjjrU4SjrS U4SjjrSrU=r $) r ia 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 arbitrary domain specific stratifications of the samples as integers. For instance the groups could be the year of collection of the samples and thus allow for cross-validation against time-based splits. The difference between :class:`LeavePGroupsOut` and ``GroupShuffleSplit`` is that the former generates splits using all subsets of size ``p`` unique groups, whereas ``GroupShuffleSplit`` generates a user-determined number of random test splits, each with a user-determined fraction of unique groups. For example, a less computationally intensive alternative to ``LeavePGroupsOut(p=10)`` would be ``GroupShuffleSplit(test_size=10, n_splits=100)``. Contrary to other cross-validation strategies, the random splits do not guarantee that test sets across all folds will be mutually exclusive, and might include overlapping samples. However, this is still very likely for sizeable datasets. Note: The parameters ``test_size`` and ``train_size`` refer to groups, and not to samples as in :class:`ShuffleSplit`. Read more in the :ref:`User Guide `. For visualisation of cross-validation behaviour and comparison between common scikit-learn split methods refer to :ref:`sphx_glr_auto_examples_model_selection_plot_cv_indices.py` Parameters ---------- n_splits : int, default=5 Number of re-shuffling & splitting iterations. test_size : float, int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of groups to include in the test split (rounded up). If int, represents the absolute number of test groups. If None, the value is set to the complement of the train size. If ``train_size`` is also None, it will be set to 0.2. train_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the groups to include in the train split. If int, represents the absolute number of train groups. If None, the value is automatically set to the complement of the test size. random_state : int, RandomState instance or None, default=None Controls the randomness of the training and testing indices produced. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import GroupShuffleSplit >>> X = np.ones(shape=(8, 2)) >>> y = np.ones(shape=(8, 1)) >>> groups = np.array([1, 1, 2, 2, 2, 3, 3, 3]) >>> print(groups.shape) (8,) >>> gss = GroupShuffleSplit(n_splits=2, train_size=.7, random_state=42) >>> gss.get_n_splits() 2 >>> print(gss) GroupShuffleSplit(n_splits=2, random_state=42, test_size=None, train_size=0.7) >>> for i, (train_index, test_index) in enumerate(gss.split(X, y, groups)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}, group={groups[train_index]}") ... print(f" Test: index={test_index}, group={groups[test_index]}") Fold 0: Train: index=[2 3 4 5 6 7], group=[2 2 2 3 3 3] Test: index=[0 1], group=[1 1] Fold 1: Train: index=[0 1 5 6 7], group=[1 1 3 3 3] Test: index=[2 3 4], group=[2 2 2] See Also -------- ShuffleSplit : Shuffles samples to create independent test/train sets. LeavePGroupsOut : Train set leaves out all possible subsets of `p` groups. Nrc4>[TU]UUUUS9 SUlg)Nrg?rrs rArGroupShuffleSplit.__init__vrrCc#N># Uc [S5e[USSSS9n[R"USS9upE[T U]US9H^upg[R "[R"XV55n[R "[R"XW55n X4v M` g7f)Nrr5FrTr)r?)r{rrTrr;r flatnonzeror) r>r?r@r5classes group_indices group_train group_testrrr8s rArGroupShuffleSplit._iter_indicess >IJ JVEQUV!#6$!G',w'>"''-"DED+ (HsB"B%c$>[TU]XU5$)aGenerate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,), default=None The target variable for supervised learning problems. groups : array-like of shape (n_samples,) Group labels for the samples used while splitting the dataset into train/test set. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. Notes ----- Randomized CV splitters may return different results for each call of split. You can make the results identical by setting `random_state` to an integer. rr=s rAr<GroupShuffleSplit.splits<w}Q6**rCrrrE r9rFrGrHrIrrr<rJrKrLs@rAr r s4Up &'+4 & & ++rCr cX^\rSrSrSrS SSSS.U4SjjjrS SjrS U4SjjrSrU=r $) r,iaD Class-wise stratified ShuffleSplit cross-validator. Provides train/test indices to split data in train/test sets. This cross-validation object is a merge of :class:`StratifiedKFold` and :class:`ShuffleSplit`, which returns stratified randomized folds. The folds are made by preserving the percentage of samples for each class in `y` in a binary or multiclass classification setting. Note: like the :class:`ShuffleSplit` strategy, stratified random splits do not guarantee that test sets across all folds will be mutually exclusive, and might include overlapping samples. However, this is still very likely for sizeable datasets. Read more in the :ref:`User Guide `. For visualisation of cross-validation behaviour and comparison between common scikit-learn split methods refer to :ref:`sphx_glr_auto_examples_model_selection_plot_cv_indices.py` .. note:: Stratification on the class label solves an engineering problem rather than a statistical one. See :ref:`stratification` for more details. Parameters ---------- n_splits : int, default=10 Number of re-shuffling & splitting iterations. test_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split. If int, represents the absolute number of test samples. If None, the value is set to the complement of the train size. If ``train_size`` is also None, it will be set to 0.1. train_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the train split. If int, represents the absolute number of train samples. If None, the value is automatically set to the complement of the test size. random_state : int, RandomState instance or None, default=None Controls the randomness of the training and testing indices produced. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import StratifiedShuffleSplit >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 0, 1, 1, 1]) >>> sss = StratifiedShuffleSplit(n_splits=5, test_size=0.5, random_state=0) >>> sss.get_n_splits(X, y) 5 >>> print(sss) StratifiedShuffleSplit(n_splits=5, random_state=0, ...) >>> for i, (train_index, test_index) in enumerate(sss.split(X, y)): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[5 2 3] Test: index=[4 1 0] Fold 1: Train: index=[5 1 4] Test: index=[0 2 3] Fold 2: Train: index=[5 0 2] Test: index=[4 3 1] Fold 3: Train: index=[4 1 0] Test: index=[2 3 5] Fold 4: Train: index=[0 5 1] Test: index=[3 4 2] Nrc4>[TU]UUUUS9 SUlgrrrs rArStratifiedShuffleSplit.__init__ rrCc ## [U5n[USSSS9n[UURURUR S9upV[ U5upx[X'S9nURS:XaE[R"UV s/sH#n SRU RS55PM% sn 5n[R"US S 9upU RS n [R"U 5n [R "U 5S:a [#S 5eX\:a[#S X\4-5eXl:a[#SXl4-5e[R$"[R&"U SS9[R("U 5SS5n[+UR,5n[/UR05Hn[3XU5nU U- n[3UXo5n/n/n[/U 5HanUR5U U5nUUR7USS9nUR9USUU5 UR9UUUUUUU-5 Mc UR5U5nUR5U5nUU4v M gs sn f7f)Nr@Frr)rr  strTrrzThe least populated class in y has only 1 member, which is too few. The minimum number of groups for any class cannot be less than 2.zLThe train_size = %d should be greater or equal to the number of classes = %dzKThe test_size = %d should be greater or equal to the number of classes = %drrrclip)mode)rrrr<rrrrndimrTrjoinastypershaperrr{r<rcumsumrrr}rrrtakeextend)r>r?r@r5r~rrrrrowr y_indicesr class_counts class_indicesrn_iclass_counts_remainingt_irrrrperm_indices_class_is rAr$StratifiedShuffleSplit._iter_indices sb O cU$ G1  NN OO"55  a  a ' 66Q;C##((3::e#45CDAYYq>MM!$ {{9- 66, ! ##   69@8LM   69?8KL  JJy{ 3RYY|5LSb5Q !!2!23t}}%A$L3?C%1C%7 "#$:FHCED9%!ool1o> '4Q'7'<'<[v'<'V$ 1(CF;< 0Q#a&3q6/JK &OOE*E??4(D+ )&CDsA>I+*I&*GI+c>Ub2[R"SURR3[5 [ USSSS9n[ TU]XU5$)aGenerate indices to split data into training and test set. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. Note that providing ``y`` is sufficient to generate the splits and hence ``np.zeros(n_samples)`` may be used as a placeholder for ``X`` instead of actual training data. y : array-like of shape (n_samples,) or (n_samples, n_labels) The target variable for supervised learning problems. Stratification is done based on the y labels. groups : object Always ignored, exists for compatibility. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. Notes ----- Randomized CV splitters may return different results for each call of split. You can make the results identical by setting `random_state` to an integer. Nr3r@Frr r=s rAr<StratifiedShuffleSplit.splitV rrCrrrlrrLs@rAr,r,s6Nb &(,D & &HT(+(+rCr,cUcUcUn[R"U5RRn[R"U5RRnUS:Xa X:dUS::dUS:Xa&US::dUS:a[ SR X55eUS:Xa X :dUS::dUS:Xa&US::dUS:a[ SR X 55eUb US;a[ SR U55eUb US;a[ S R U55eUS:Xa*US:Xa$X!-S:a[ S R X!-55eUS:Xa[ X-5nOUS:Xa [U5nUS:Xa[X -5nOUS:Xa [U5nUcUW- nOUcUW- nWW-U:a[ S Xv-U4-5e[U5[U5pgUS:Xa[ S R XU55eXv4$) zl Validation helper to check if the train/test sizes are meaningful w.r.t. the size of the data (n_samples). rrrrzzqtest_size={0} should be either positive and smaller than the number of samples {1} or a float in the (0, 1) rangezrtrain_size={0} should be either positive and smaller than the number of samples {1} or a float in the (0, 1) range)rrz Invalid value for train_size: {}zInvalid value for test_size: {}zlThe sum of test_size and train_size = {}, should be in the (0, 1) range. Reduce test_size and/or train_size.z~The sum of train_size and test_size = %d, should be smaller than the number of samples %d. Reduce test_size and/or train_size.zWith n_samples={}, test_size={} and train_size={}, the resulting train set will be empty. Adjust any of the aforementioned parameters.) rTrr^rr{r|r floatr r)r~r<rrtest_size_typetrain_size_typerrs rArr s4 Z/% ZZ *0055Njj,2277O#9#9Y!^#9>Y!^ !6)7  3J$;zQ3J!OzQ !6*8  /"C;BB:NOOz!A:AA)LMM#.C"7J\rSrSrSrSrS SjrSrSrS Sjr S r g) r&i aPredefined split cross-validator. Provides train/test indices to split data into train/test sets using a predefined scheme specified by the user with the ``test_fold`` parameter. Read more in the :ref:`User Guide `. .. versionadded:: 0.16 Parameters ---------- test_fold : array-like of shape (n_samples,) The entry ``test_fold[i]`` represents the index of the test set that sample ``i`` belongs to. It is possible to exclude sample ``i`` from any test set (i.e. include sample ``i`` in every training set) by setting ``test_fold[i]`` equal to -1. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import PredefinedSplit >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> test_fold = [0, 1, -1, 1] >>> ps = PredefinedSplit(test_fold) >>> ps.get_n_splits() 2 >>> print(ps) PredefinedSplit(test_fold=array([ 0, 1, -1, 1])) >>> for i, (train_index, test_index) in enumerate(ps.split()): ... print(f"Fold {i}:") ... print(f" Train: index={train_index}") ... print(f" Test: index={test_index}") Fold 0: Train: index=[1 2 3] Test: index=[0] Fold 1: Train: index=[0 2] Test: index=[1 3] c[R"U[S9Ul[ UR5Ul[R "UR5UlUR UR S:gUlg)Nr]r)rTrr test_foldrr unique_folds)r>rs rArPredefinedSplit.__init__ sW)37%dnn5IIdnn5 --d.?.?2.EFrCNcUb2[R"SURR3[5 UR 5$)Generate indices to split data into training and test set. Parameters ---------- X : object Always ignored, exists for compatibility. y : object Always ignored, exists for compatibility. groups : object Always ignored, exists for compatibility. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. r3rArfs rAr<PredefinedSplit.split s<,   MM5dnn6M6M5NO {{}rCc## [R"[UR55nUR 5H%nU[R "U5nXnX24v M' g7f)zGenerate indices to split data into training and test set. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. N)rTrUrrrVrW)r>indrYrZs rArBPredefinedSplit._split sTiiDNN+,//1JbnnZ89KJ) )2sA$A&c## URH]n[R"URU:H5Sn[R"[ UR5[ S9nSX2'Uv M_ g7f)z3Generates boolean masks corresponding to test sets.rr]TN)rrTrrr`rra)r>rrYrbs rArV PredefinedSplit._iter_test_masks* sW""A$..A"56q9JT^^!4DAI$(I !O #sA/A1c,[UR5$r)rrrfs rAriPredefinedSplit.get_n_splits2 s&4$$%%rC)rrrs) r9rFrGrHrIrr<rBrVrirJrDrCrAr&r& s"'RG :*"&rCr&c2\rSrSrSrSrSSjrSSjrSrg) _CVIterableWrapperiH z5Wrapper class for old style cv objects and iterables.c$[U5Ulgrl)listrn)r>rns rAr_CVIterableWrapper.__init__K s r(rCNc,[UR5$r)rrnrfs rAri_CVIterableWrapper.get_n_splitsN s&477|rCc#@# URH upEXE4v M g7f)rNrnrs rAr<_CVIterableWrapper.splitc s, 77KE+ #srrs) r9rFrGrHrIrrir<rJrDrCrArrH s?*rCrF) classifiercUcSOUn[U[R5(a.U(aUb[USS9S;a [ U5$[ U5$[ US5(a[U[5(aC[U[5(a[U[5(a[SU-5e[U5$U$)aInput checker utility for building a cross-validator. Parameters ---------- cv : int, cross-validation generator, iterable or None, default=5 Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 5-fold cross validation, - integer, to specify the number of folds. - :term:`CV splitter`, - An iterable that generates (train, test) splits as arrays of indices. For integer/None inputs, if classifier is True and ``y`` is either binary or multiclass, :class:`StratifiedKFold` is used. In all other cases, :class:`KFold` is used. Refer :ref:`User Guide ` for the various cross-validation strategies that can be used here. .. versionchanged:: 0.22 ``cv`` default value changed from 3-fold to 5-fold. y : array-like, default=None The target variable for supervised learning problems. classifier : bool, default=False Whether the task is a classification task, in which case stratified KFold will be used. Returns ------- checked_cv : a cross-validator instance. The return value is a cross-validator which generates the train/test splits via the ``split`` method. Examples -------- >>> from sklearn.model_selection import check_cv >>> check_cv(cv=5, y=None, classifier=False) KFold(...) >>> check_cv(cv=5, y=[1, 1, 0, 0, 0, 0], classifier=True) StratifiedKFold(...) rr@)rrr<ziExpected cv as an integer, cross-validation object (from sklearn.model_selection) or an iterable. Got %s.) rrrrr+r!hasattrrrr{r)rnr@rs rAr-r-} sXjbB"g&&'' c26NN"2& &9  2w  :b##6#6"h'':b#+>+>*,./  ""%% IrCrzneither)closedleftrbooleanz array-like)r<rrrstratifyT)prefer_skip_nested_validationc^ ^ [U5nUS:Xa [S5e[U6n[US5n[ XpUSS9upUSLa>Ub [S5e[ R "U5m [ R "XU -5m O6Ub[n O[n U "XUS9n [U RUSUS95um m [UST T 5um m [[R"U U 4S jU555$) aCSplit arrays or matrices into random train and test subsets. Quick utility that wraps input validation, ``next(ShuffleSplit().split(X, y))``, and application to input data into a single call for splitting (and optionally subsampling) data into a one-liner. Read more in the :ref:`User Guide `. Parameters ---------- *arrays : sequence of indexables with same length / shape[0] Allowed inputs are lists, numpy arrays, scipy-sparse matrices or pandas dataframes. test_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split. If int, represents the absolute number of test samples. If None, the value is set to the complement of the train size. If ``train_size`` is also None, it will be set to 0.25. train_size : float or int, default=None If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the train split. If int, represents the absolute number of train samples. If None, the value is automatically set to the complement of the test size. random_state : int, RandomState instance or None, default=None Controls the shuffling applied to the data before applying the split. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. shuffle : bool, default=True Whether or not to shuffle the data before splitting. If shuffle=False then stratify must be None. stratify : array-like, default=None If not None, data is split in a stratified fashion, using this as the class labels. Read more in the :ref:`User Guide `. Returns ------- splitting : list, length=2 * len(arrays) List containing train-test split of inputs. .. versionadded:: 0.16 If the input is sparse, the output will be a ``scipy.sparse.csr_matrix``. Else, output type is the same as the input type. Examples -------- >>> import numpy as np >>> from sklearn.model_selection import train_test_split >>> X, y = np.arange(10).reshape((5, 2)), range(5) >>> X array([[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]) >>> list(y) [0, 1, 2, 3, 4] >>> X_train, X_test, y_train, y_test = train_test_split( ... X, y, test_size=0.33, random_state=42) ... >>> X_train array([[4, 5], [0, 1], [6, 7]]) >>> y_train [2, 0, 3] >>> X_test array([[2, 3], [8, 9]]) >>> y_test [1, 4] >>> train_test_split(y, shuffle=False) [[0, 1, 2], [3, 4]] >>> from sklearn import datasets >>> iris = datasets.load_iris(as_frame=True) >>> X, y = iris['data'], iris['target'] >>> X.head() sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) 0 5.1 3.5 1.4 0.2 1 4.9 3.0 1.4 0.2 2 4.7 3.2 1.3 0.2 3 4.6 3.1 1.5 0.2 4 5.0 3.6 1.4 0.2 >>> y.head() 0 0 1 0 2 0 3 0 4 0 ... >>> X_train, X_test, y_train, y_test = train_test_split( ... X, y, test_size=0.33, random_state=42) ... >>> X_train.head() sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) 96 5.7 2.9 4.2 1.3 105 7.6 3.0 6.6 2.1 66 5.6 3.0 4.5 1.5 0 5.1 3.5 1.4 0.2 122 7.7 2.8 6.7 2.0 >>> y_train.head() 96 1 105 2 66 1 0 0 122 2 ... >>> X_test.head() sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) 73 6.1 2.8 4.7 1.2 18 5.7 3.8 1.7 0.3 118 7.7 2.6 6.9 2.3 78 6.0 2.9 4.5 1.5 76 6.8 2.8 4.8 1.4 >>> y_test.head() 73 1 18 0 118 2 78 1 76 1 ... rz$At least one array required as inputg?rFz@Stratified train/test split is not implemented for shuffle=Falser)r?r@c3T># UHn[UT5[UT54v M g7frl)r)rgarrs rArj#train_test_split.. s' IOA^Au %~a'> ?s%()rr{rrrrTrUr,r)nextr<rrr from_iterable)r<rrrrarraysn_arraysr~rrCVClassrnrrs @@rAr.r. s @6{H1}?@@  FVAY'I-jDOG%  R  '"yyF"23  ,G"G v U288fQi88<= t0E4HKE4   IO   rC__test__c[R"5n[R"SSSS9 [5nUnSSUS--S--n[ [ UR 555Hunup[U [5(aU<S[U 5<3n OU<SU"U 5<3n [U 5S :aU S S S -U S S -n US:aKU[U 5-S:dSU ;aURU5 [U5nOURS5 US- nURU 5 U[U 5- nM [R"S0UD6 SRU5n SRSU RS555n U $)a>Pretty print the dictionary 'params' Parameters ---------- params : dict The dictionary to pretty print offset : int, default=0 The offset in characters to add at the begin of each line. printer : callable, default=repr The function to convert entries to strings, typically the builtin str or repr r@r ) precision threshold edgeitemsz, rzr=iNi,z...irK z, c3B# UHoRS5v M g7f)rN)rstrip)rgr[s rArj_pprint.. s?->hhsmm->srD)rTget_printoptionsset_printoptionsrrsorteditemsrrrrappendrr<) paramsoffsetprinteroptions params_listthis_line_lengthline_seprrv this_reprliness rA_pprintr sm"!!#G!rQ?&KFaK3..Hvflln56 6A a  $%c!f-I$%gaj1I y>C !$3%/)DE2BBI q5#i.0B6$):K""8,#&x= ""4( A% 9%C N*'7*"'" GGK E II?U[[->? ?E LrCc2URn[URSUR5n[U5nU[RLa/nOl[ UR R5Vs/sH=nURS:wdMURUR:wdM1URPM? sn5nURRn[5nUHn[R"S[5 [R "SS9n [XS5n U c-[#US5(aUR$R'US5n SSS5 [)W 5(a8U SR*[La"[R,R/S5 M[R,R/S5 W Xx'M U<S[1U[)U5S 9<S 3$s snf!,(df  N=f![R,R/S5 f=f) Ndeprecated_originalr>alwaysT)recordrir()r))r8getattrrrobjectr  parametersvaluesnamer VAR_KEYWORDr9dictr6 simplefilter FutureWarningcatch_warningsrrigetrcategoryfilterspopr) r>clsinitinit_signatureargsr class_namerrhwvalues rArnrn s ..C 3<rIs'#$)  LK-7-FF *22D1,1@!+w@!FL*,>L^Y>(*<Y>x[#w[|] $j]@W+$jW+tJ+jJ+ZP. PfSjSlt+*,>t+nB+)+=B+Jh!(Gh!V? ,o? Dn26n2bt!)Wt!nf&+-=f&RO++-=O+dN+-N+bHVy&(y&x2+2j@@F ZAi 8 W%%q$v >  ZAi 8 W%%q$v >  ((;!4(#'!(   r%$rp*e,d/d%LPErC