0Ph dZddlZddlZddlmZmZddlmZddlm Z ddl m Z ddl m Z mZddlmZmZddlZdd lmZd d lmZmZmZmZd d lmZmZmZd d lm Z m!Z!m"Z"d dl#m$Z$d dl%m&Z&d dl'm(Z(d dl)m*Z*m+Z+m,Z,gdZ-GddZ.Gdde&Z/Gdde&eZ0Gdde.e0Z1Gdde.e0Z2Gdde0eZ3Gd d!e.e3Z4Gd"d#e/e3Z5Gd$d%e3Z6Gd&d'e/e3Z7Gd(d)e3Z8Gd*d+e/e0Z9Gd,d-e/e0Z:Gd.d/e&eZ;Gd0d1e.e;Z<Gd2d3e.e;Z=Gd4d5e&eZ>Gd6d7e.e>Z?Gd8d9e/e>Z@Gd:d;e>ZAdTd<ZBGd=d>e0ZCGd?d@e0ZDdUdBdCdDZEe"e e!ddEdFGe ejFdEddHGdge e!ddEdFGe ejFdEddHGdgdIgdJgdKdgdLdMNddddMddLdOZGeHeGdPdBdeIfdQZJdRZKdSZLdS)Vz 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)BaseCrossValidatorKFold GroupKFoldLeaveOneGroupOut LeaveOneOutLeavePGroupsOut LeavePOutRepeatedStratifiedKFold RepeatedKFold ShuffleSplitGroupShuffleSplitStratifiedKFoldStratifiedGroupKFoldStratifiedShuffleSplitPredefinedSplittrain_test_splitcheck_cvc$eZdZdZdfd ZxZS)_UnsupportedGroupCVMixinz/Mixin for splitters that do not support Groups.Nc|'tjd|jjtt |||S)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. N#The groups parameter is ignored by groups)warningswarn __class____name__ UserWarningsupersplitselfXyr4r7s ^/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/model_selection/_split.pyr;z_UnsupportedGroupCVMixin.split>sP.   MOdn6MOO   ww}}Q&}111NN)r8 __module__ __qualname____doc__r; __classcell__r7s@r@r0r0;sC992222222222rAr0ceZdZdZddiZdS)GroupsConsumerMixinzA Mixin to ``groups`` by default. This Mixin makes the object to request ``groups`` by default as ``True``. .. versionadded:: 1.3 r4TN)r8rCrDrE-_GroupsConsumerMixin__metadata_request__splitrAr@rIrI]s'"*4 0rArIcZeZdZdZdejiZd dZd dZd dZ e d dZ dZ dS) rzvBase class for all cross-validators. Implementations must define `_iter_test_masks` or `_iter_test_indices`. r4Nc#Kt|||\}}}tjt|}||||D]*}|tj|}||}||fV+dS)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. N)rnparanger_iter_test_masks logical_not)r=r>r?r4indices test_index train_indexs r@r;zBaseCrossValidator.splitts0!Av.. 1f)LOO,,//1f== * *J!"."<"<=K ,Jz) ) ) ) ) * *rAc#K||||D]3}tjt|t}d||<|V4dS)zGenerates boolean masks corresponding to test sets. By default, delegates to _iter_test_indices(X, y, groups) dtypeTN)_iter_test_indicesrNzerosrbool)r=r>r?r4rS test_masks r@rPz#BaseCrossValidator._iter_test_maskssb 11!Q??  Ja===I$(Ij !OOOO  rAct)z5Generates integer indices corresponding to test sets.)NotImplementedErrorr=r>r?r4s r@rXz%BaseCrossValidator._iter_test_indicess!!rAcdS)zBReturns the number of splitting iterations in the cross-validator.NrKr^s r@ get_n_splitszBaseCrossValidator.get_n_splitssrAc t|SN _build_reprr=s r@__repr__zBaseCrossValidator.__repr__4   rArBNNN) r8rCrDrErUNUSED,_BaseCrossValidator__metadata_request__splitr;rPrXrr`rfrKrAr@rrhs"*+;+B C****B""""QQQ^Q!!!!!rAr) metaclassc"eZdZdZddZddZdS)r"aLeave-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. Nct|}|dkr"td|t|S)Nz-Cannot perform LeaveOneOut with n_samples={}.)r ValueErrorformatrange)r=r>r?r4 n_sampless r@rXzLeaveOneOut._iter_test_indicessI OO >>?FFyQQ YrAcB|tdt|S)aHReturns 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. N%The 'X' parameter should not be None.)rorr^s r@r`zLeaveOneOut.get_n_splitss$( 9DEE EArArB)r8rCrDrErXr`rKrAr@r"r"sG++Z    rAr"c(eZdZdZdZddZddZdS)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] c||_dSrb)p)r=rws r@__init__zLeavePOut.__init__4s rANc#Kt|}||jkr(td|j|t t ||jD]}t j|VdS)Nz8p={} must be strictly less than the number of samples={})rrwrorpr rqrNarray)r=r>r?r4rr combinations r@rXzLeavePOut._iter_test_indices7s OO   JQQFI  (i(8(8$&AA ( (K(;'' ' ' ' ' ( (rAc|tdttt||jdS)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. NrtTexact)rointr rrwr^s r@r`zLeavePOut.get_n_splitsBs= 9DEE E4 Qt<<<===rArB)r8rCrDrErxrXr`rKrAr@r$r$sV77r ( ( ( (>>>>>>rAr$cBeZdZdZedZdfd ZddZxZS) _BaseKFoldz;Base class for K-Fold cross-validators and TimeSeriesSplit.ct|tjs#td|dt |dt |}|dkr"td|t|ts"td||s|td||_ ||_ ||_ dS)Nz.The number of folds must be of Integral type. z of type z was passed.rnzok-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.) isinstancenumbersIntegralrotyperrprZ TypeErrorn_splitsshuffle random_state)r=rrrs r@rxz_BaseKFold.__init__Ys(G$455 */7xxhI x== q==%%+VH%5%5  '4(( VDKKGTTUU U <3O !  (rANc#Kt|||\}}}t|}|j|kr(td|j|t |||D] \}}||fV dS)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,), 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)rrrrorpr:r;)r=r>r?r4rrtraintestr7s r@r;z_BaseKFold.splitys0!Av.. 1f OO =9 $ $B& 22  !77==Av66  KE4+      rAc|jSaReturns 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. rr^s r@r`z_BaseKFold.get_n_splits &}rArBrh) r8rCrDrErrxr;r`rFrGs@r@rrVsqEE))^)>######JrArc4eZdZdZddddfd Zd dZxZS) raB 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. FNrrcPt|||dSN)rrrr:rxr=rrrr7s r@rxzKFold.__init__( (G,WWWWWrAc#ZKt|}tj|}|jr't |j||j}tj|||zt}|d||zxxdz cc<d}|D]} ||| z} } || | V| }dS)NrVrnr) rrNrOrrrrfullr) r=r>r?r4rrrRr fold_sizescurrent fold_sizestartstops r@rXzKFold._iter_test_indicess OO )I&& < C t0 1 1 9 9' B B B=WXyH'eZdZdZd dddfd ZdZd fd ZxZS) r a K-fold iterator variant with non-overlapping groups. 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 folds are approximately balanced in the sense that the number of samples is approximately the same in each test fold when `shuffle` is True. 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 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). rFNrcPt|||dS)Nrrrs r@rxzGroupKFold.__init___s( 7NNNNNrAc#K|tdt|ddd}tj|d\}}t |}|j|krtd|j|fz|jr{t|j}| |}tj ||j}|D]3} tj || } tj | dV4dStj |} tj| ddd } | | } tj|j} tjt |}t!| D]4\}}tj| }| |xx|z cc<||| |<5||} t%|jD]"}tj | |kdV#dS) N*The 'groups' parameter should not be None.r4F input_name ensure_2drWTreturn_inversezOCannot have number of splits n_splits=%d greater than the number of groups: %d.r)rorrNuniquelenrrrr permutation array_splitisinwherebincountargsortrY enumerateargminrq)r=r>r?r4 unique_groups group_idxn_groupsrng split_groupstest_group_idsr[n_samples_per_grouprRn_samples_per_fold group_to_fold group_indexweight lightest_foldfs r@rXzGroupKFold._iter_test_indicesbs( >IJJ JVEQUVVV#%9VD#I#I#I y}%% =8 # #259]H4MN  <! 0$T%677COOM::M>-GGL". - -GFN;; hy))!,,,,, - - #%+i"8"8 j!455ddd;G"5g"> "$$-!8!8 HS%7%788M(11D'E'E D D# V " *< = = "=111V;1116C gk233#I.G4=)) 0 0hw!|,,Q///// 0 0rAcJt|||SaGenerate 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 r@r;zGroupKFold.split0ww}}Q6***rArrB)r8rCrDrErxrXr;rFrGs@r@r r sHHTOe$OOOOOOO/0/0/0b++++++++++rAr cHeZdZdZd dddfd Zd dZd dZd fd ZxZS) r)a 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. 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 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. rFNrcPt|||dSrrrs r@rxzStratifiedKFold.__init__rrActj}t|\}}|rt||}nt j|}t |}d}||vr#td||t|}t j |dd\}} } t j | d\}} | | } t| t j | } t j | }t jj| krtdjzj|kr$t!jd|jfzt$t j| t jfdt)jD}t jt|d }t)D]]}t jj|dd|f}jr||||| |k<^|S) 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.cXg|]&}tj|dj'S)N) minlength)rNrr).0i n_classesr=y_orders r@ z4StratifiedKFold._make_test_folds..1sG    GA$6$679MMM   rArrV)rrrrrNasarrayrrorprrrrminallrr5r6r9sortrqemptyrOrepeatr)r=r>r?rxp is_array_apitype_of_target_yallowed_target_types_y_idxy_inv class_perm y_encodedy_counts min_groups allocation test_foldskfolds_for_classrrs` @@r@_make_test_foldsz StratifiedKFold._make_test_foldssw !233 )++L  !!R((AA 1 A)!,,7 #7 7 7CJJ(*:  OO)ADNNN5% %=== :u% JJ ;y))VH%% 6$-(* + + 47;}F  =: % % M<t}-.    ')$$Z      t}--     Xc!ffC000 y!! 9 9A!i 66==jA>NOOO| - O,,,)8JyA~ & &rAc#tK|||}t|jD] }||kV dSrb)rrqr)r=r>r?r4rrs r@rPz StratifiedKFold._iter_test_masksEsQ**1a00 t}%% " "A/ ! ! ! ! " "rAc|'tjd|jjtt |ddd}t |||S)mGenerate 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. Nr2r?Frr5r6r7r8r9rr:r;r<s r@r;zStratifiedKFold.splitJeD   MOdn6MOO    cU$ G G Gww}}Q6***rArrbrB) r8rCrDrErxrrPr;rFrGs@r@r)r)sKKZXe$XXXXXXXDDDDL"""" (+(+(+(+(+(+(+(+(+(+rAr)c0eZdZdZdfd ZdZdZxZS) r*aStratified 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. 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` 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. rFNcPt|||dSrrrs r@rxzStratifiedGroupKFold.__init__rrAc#Kt|j}tj|}t |}d}||vr#t d||t|}tj|dd\}}} tj |j | krt d|j ztj | } |j | kr$tj d| |j fztt| } tj|dd\}} } tjt| | f}t#|| D]\}}|||fxxdz cc<tj|j | f}t%t&|jr||tjtj|d d }|D]M}||}||| | }||xx|z cc<||Nt3|j D]"fd t5| D}|V#dS) NrrT)r return_countsrrrnaxis mergesortkind)y_counts_per_foldy_cntgroup_y_countsc.g|]\}}|v|SrKrK)ridxrgroups_per_foldrs r@rz;StratifiedGroupKFold._iter_test_indices..%s7"C 222222rA)rrrNrrrorprrrrrr5r6r9rrYziprsetrrstd_find_best_foldaddrqr)r=r>r?r4rrrrrrn_smallest_classr groups_inv groups_cnty_counts_per_group class_idxrrsorted_groups_idxr best_fold test_indicesrrs @@r@rXz'StratifiedGroupKFold._iter_test_indicess !!233 JqMM)!,,7 #7 7 7CJJ(*:  OO)Ad$OOO5% 6$-%' ( ( 47;}F 6%== =+ + + M<#T]34     JJ $&I 4t% % % !:z Xs: &BCC$'z$:$: : : Iy y)3 4 4 4 9 4 4 4 4HdmY%?@@%c** < , KK* + + +J V&Q / / / /k   + 6 6I/ :N,,"3--I i ( ( (N : ( ( ( I & * *9 5 5 5 5t}%%  A&/ &;&;L        rAcd}tj}tj}t|jD]}||xx|z cc<tj||ddz d}||xx|zcc<tj|} tj||} | |kptj| |o| |k} | r| }| }|}|S)Nrnrrr) rNinfrqrrreshapemeansumisclose) r=rrrr min_evalmin_samples_in_foldr std_per_class fold_evalsamples_in_foldis_current_fold_betters r@rz$StratifiedGroupKFold._find_best_fold,s 6 ft}%%  A a N 2 F#4u}}Q7K7K#KRSTTTM a N 2  ..I f%6q%9::OH$::i22:#&99 # & $&5# rA)rFN)r8rCrDrErxrXrrFrGs@r@r*r*usr``DXXXXXXOOObrAr*c<eZdZdZd ddddfd Zd dZdZxZS) TimeSeriesSplitaTime Series cross-validator. Provides train/test indices to split time series data samples that are observed at fixed time intervals, in train/test sets. In each split, test indices must be higher than before, and thus shuffling in cross validator is inappropriate. This cross-validation object is a variation of :class:`KFold`. In the kth split, it returns first k folds as train set and the (k+1)th fold as 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. rNr)max_train_size test_sizegapczt|dd||_||_||_dS)NFr)r:rxrrr)r=rrrrr7s r@rxzTimeSeriesSplit.__init__s< 5tDDD,"rAc~|'tjd|jjt||S)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,) 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. Nr2r5r6r7r8r9_splitr^s r@r;zTimeSeriesSplit.splitsC.   MOdn6MOO   {{1~~rAc #(Kt|\}t|}|j}|dz}|j}|j|jn||z}||krt d|d|d||z ||zz dkrt d|d|d |d |d t j|}t|||zz ||}|D]T} | |z } |j r-|j | kr"|| |j z | || | |zfV;|d| || | |zfVUdS) 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. Yields ------ train : ndarray The training set indices for that split. test : ndarray The testing set indices for that split. rnNzCannot 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=) rrrrrrorNrOrqr) r=r>rrrn_foldsrrrR test_starts test_start train_ends r@r#zTimeSeriesSplit._splits"|| OO =Q,h"n8DNNi7>R  Y  `. 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#K|tdt|dddd}tj|}t |dkrtd|z|D] }||kV dS)Nrr4TFrcopyrrWrnzcThe groups parameter contains fewer than 2 unique groups (%s). LeaveOneGroupOut expects at least 2.)rorrNrr)r=r>r?r4rrs r@rPz!LeaveOneGroupOut._iter_test_masksHs >IJJ J xde4    &)) }   " "=?LM   AA+      rANc|tdt|ddd}ttj|S)Returns 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. Nrr4Fr)rorrrNrr^s r@r`zLeaveOneGroupOut.get_n_splitsXsG, >IJJ JVEQUVVV29V$$%%%rAcJt|||Srrr<s r@r;zLeaveOneGroupOut.splitsrrArhrB)r8rCrDrErPr`r;rFrGs@r@r!r!sk..` &&&&6++++++++++rAr!c8eZdZdZdZdZddZdfd ZxZS) r#acLeave 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. c||_dSrb)r)r=rs r@rxzLeavePGroupsOut.__init__s   rAc#K|tdt|dddd}tj|}|jt |kr"td|j||jdzfzt tt ||j}|D]T}tjt|t}|tj |D] }d|||k< |VUdS) Nrr4TFr,zThe 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 presentrnrV) rorrNrrrr rqrYrrZrz) r=r>r?r4rcombirRrSls r@rPz LeavePGroupsOut._iter_test_maskss% >IJJ J xde4    &)) =C .. . ."]M4=1;LMN  U3}#5#566 FF  G,q//>>>J"28G#4#45 / /*. 6Q;''       rANc |tdt|ddd}ttt t j||jdS)r/Nrr4FrTr})rorrr rrNrrr^s r@r`zLeavePGroupsOut.get_n_splitss`, >IJJ JVEQUVVV4BIf--.. TJJJKKKrAcJt|||Srrr<s r@r;zLeavePGroupsOut.splitrrArhrB) r8rCrDrErxrPr`r;rFrGs@r@r#r#s~44l!!!*LLLL6++++++++++rAr#cHeZdZdZdejiZddddZd dZd dZ d Z dS) _RepeatedSplitsaRepeated 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. r4 N) n_repeatsrc t|tjstd|dkrtdt fddDrtd||_||_||_|_dS)Nz/Number of repetitions must be of Integral type.rz-Number of repetitions must be greater than 0.c3 K|]}|vV dSrbrK)rkeycvargss r@ z+_RepeatedSplits.__init__..8s'DDsf}DDDDDDrArrz0cvargs must not contain random_state or shuffle.) rrrroanycvr;rr?)r=rCr;rr?s `r@rxz_RepeatedSplits.__init__1s)W%566 PNOO O >>LMM M DDDD(CDDD D D QOPP P"( rAc#K|j}t|j}t|D]:}|jd|dd|j}||||D] \}} || fV ;dS)aGenerates 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. TrANrK)r;rrrqrCr?r;) r=r>r?r4r;rrrCrTrSs r@r;z_RepeatedSplits.split@s0N  !233## . .CGc4GG4;GGB+-88Aq&+A+A . .' Z!:----- . . .rAct|j}|jd|dd|j}|||||jzS)aReturns 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. TrArK)rrrCr?r`r;)r=r>r?r4rrCs r@r`z_RepeatedSplits.get_n_splits`sQ,!!233 TW C#t C Ct{ C Cq!V,,t~==rAc t|Srbrcres r@rfz_RepeatedSplits.__repr__zrgrArBrh) r8rCrDrErri(_RepeatedSplits__metadata_request__splitrxr;r`rfrKrAr@r9r9s6"*+;+B C(*     ....@>>>>4!!!!!rAr9c,eZdZdZddddfd ZxZS)r&aRepeated K-Fold cross validator. Repeats K-Fold n 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. rr:Nrr;rc\tt|||dSN)r;rr)r:rxrr=rr;rr7s r@rxzRepeatedKFold.__init__s7  Y\H      rAr8rCrDrErxrFrGs@r@r&r&~sV99v$%           rAr&c8eZdZdZddddfd Zdfd ZxZS) r%a#Repeated Stratified K-Fold cross validator. Repeats Stratified K-Fold n 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 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. rr:NrIc\tt|||dSrK)r:rxr)rLs r@rxz RepeatedStratifiedKFold.__init__s:  %      rAcrt|ddd}t|||S)rr?FNrr3)rr:r;r<s r@r;zRepeatedStratifiedKFold.splits8D cU$ G G Gww}}Q&}111rArb)r8rCrDrErxr;rFrGs@r@r%r%st;;z$%       #2#2#2#2#2#2#2#2#2#2rAr%cVeZdZdZdejiZ d dddddZd dZd dZ d d Z d Z dS)BaseShuffleSplita[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 `. r4r:Nr train_sizercL||_||_||_||_d|_dS)N皙?)rrrTr_default_test_size)r=rrrTrs r@rxzBaseShuffleSplit.__init__Ms/! "$("%rAc#zKt|||\}}}||||D] \}}||fV dS)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?r4rrs r@r;zBaseShuffleSplit.splitVsa<!Av.. 1f--aF;;  KE4+      rAc#,Kt|}t||j|j|j\}}t |j}t|jD]4}| |} | d|} | |||z} | | fV5dS)zGenerate (train, test) indicesdefault_test_sizeN) r_validate_shuffle_splitrrTrWrrrqrr) r=r>r?r4rrn_trainn_testrrrind_test ind_trains r@rYzBaseShuffleSplit._iter_indicesxs OO 1  N O"5    !!233t}%% & &A//)44K"7F7+H#Ffw.>$?@IX% % % % %  & &rAc|jSrrr^s r@r`zBaseShuffleSplit.get_n_splitsrrAc t|Srbrcres r@rfzBaseShuffleSplit.__repr__rgrAr:rBrh) r8rCrDrErri*_BaseShuffleSplit__metadata_request__splitrxr;rYr`rfrKrAr@rRrR,s<"*+;+B C&(,D&&&&&    D&&&&$*!!!!!rArRc0eZdZdZ dddddfd ZxZS)r'a 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] r:NrSc`t||||d|_dSNrrrTrrVr:rxrWr=rrrTrr7s r@rxzShuffleSplit.__init__B !%    #&rArerMrGs@r@r'r's`ZZz &(,D & & & & & & & & & & &rAr'cFeZdZdZ dddddfd ZfdZd fd ZxZS) r(aShuffle-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. rNrSc`t||||d|_dS)Nrjg?rkrls r@rxzGroupShuffleSplit.__init__drmrAc#~K|tdt|ddd}tj|d\}}t |D]Y\}}tjtj||}tjtj||} || fVZdS)Nrr4FrTr)r>)rorrNrr:rY flatnonzeror) r=r>r?r4classes group_indices group_train group_testrrr7s r@rYzGroupShuffleSplit._iter_indicesos >IJJ JVEQUVVV!#6$!G!G!G',ww'<'"'-"D"DEED+      rAcJt|||S)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 r@r;zGroupShuffleSplit.split}s<ww}}Q6***rArrBr8rCrDrErxrYr;rFrGs@r@r(r( sUUp &'+4 & & & & & & &     ++++++++++rAr(cDeZdZdZ dddddfd Zd dZd fd ZxZS) r+aZ 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. 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` 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] r:NrSc`t||||d|_dSrirkrls r@rxzStratifiedShuffleSplit.__init__rmrAc #*Kt|}t|ddd}t||j|j|j\}}t |\}}t||}|jdkrtj d|D}tj |d \} } | j d } tj | } tj| dkrtd || krtd || fz|| krtd || fztjtj| dtj| dd} t'|j}t+|jD]}t/| ||}| |z }t/|||}g}g}t+| D]}|| |}| ||d}||d||||||||||z||}||}||fVdS)Nr?Frr\)rr c^g|]*}d|d+S) str)joinastype)rrows r@rz8StratifiedShuffleSplit._iter_indices.. s0CCC##((3::e#4#455CCCrATrrzThe 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)rrr^rrTrWrrndimrNrzrshaperrror;rcumsumrrrqrrrtakeextend)r=r>r?r4rrr_r`rrrr y_indicesr class_counts class_indicesrn_iclass_counts_remainingt_irrrrperm_indices_class_is r@rYz$StratifiedShuffleSplit._iter_indicess OO cU$ G G G1  N O"5    a  A aB ' ' ' 6Q;;CCCCCDDAYq>>>M!$ {9-- 6,  ! # ##  Y  69@)8LM  I  69?8KL  Jy{ 3 3 3RY|5L5LSbS5Q  !!233t}%%  A$L'3??C%1C%7 "#$:FCHHCED9%% L L!ool1o>> '4Q'7'<'<[v'<'V'V$ 1(CF(;<<< 0Q#a&3q6/1IJKKKKOOE**E??4((D+    )  rAc|'tjd|jjtt |ddd}t |||S)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. Nr2r?Frrr<s r@r;zStratifiedShuffleSplit.split> rrArerbrwrGs@r@r+r+sHHV &(,D & & & & & & &HHHHT(+(+(+(+(+(+(+(+(+(+rAr+cd|||}tj|jj}tj|jj}|dkr ||ks|dks|dkr/|dks|dkr#t d|||dkr ||ks|dks|dkr/|dks|dkr#t d|||&|dvr"t d ||&|dvr"t d ||dkr4|dkr.||zdkr%t d ||z|dkrt ||z}n|dkrt|}|dkrt||z}n|dkrt|}|||z }n|||z }||z|krt d ||z|fzt|t|}}|dkr$t d |||||fS)zx Validation helper to check if the train/test sizes are meaningful w.r.t. the size of the data (n_samples). Nrrrrnzqtest_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.) rNrrWrrorpr floatr r)rrrrTr]test_size_typetrain_size_typer`r_s r@r^r^i s Z/% Z **05Nj,,27O # ) # #yA~~ S !^^yA~~ !6)Y77    3 9 $ $ a c ! ! 1__ a !6*i88   /"C"C;BB:NNOOOz!A!A:AA)LLMMM#.C"7"7J`. .. 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] ctj|t|_t |j|_tj|j|_|j|jdk|_dS)NrVr)rNrzr test_foldrr unique_folds)r=rs r@rxzPredefinedSplit.__init__ s[)3777%dn55Idn55 -d.?2.EFrANc||'tjd|jjt|S)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. Nr2r"r^s r@r;zPredefinedSplit.split sA,   MOdn6MOO   {{}}rAc#Ktjt|j}|D]*}|tj|}||}||fV+dS)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)rNrOrrrPrQ)r=indrSrTs r@r#zPredefinedSplit._split swiDN++,,//11 * *JbnZ889KZJz) ) ) ) ) * *rAc#K|jD][}tj|j|kd}tjt |jt }d||<|V\dS)z3Generates boolean masks corresponding to test sets.rrVTN)rrNrrrYrrZ)r=rrSr[s r@rPz PredefinedSplit._iter_test_masks sp"  A$.A"566q9JT^!4!4DAAAI$(Ij !OOOO   rAc*t|jSr)rrr^s r@r`zPredefinedSplit.get_n_splits s&4$%%%rArh) r8rCrDrErxr;r#rPr`rKrAr@r,r, sw''RGGG :***"&&&&&&rAr,c(eZdZdZdZddZddZdS)_CVIterableWrapperz5Wrapper class for old style cv objects and iterables.c.t||_dSrb)listrC)r=rCs r@rxz_CVIterableWrapper.__init__9 sr((rANc*t|jSr)rrCr^s r@r`z_CVIterableWrapper.get_n_splits< s&47||rAc#0K|jD] \}}||fV dS)rN)rCrZs r@r;z_CVIterableWrapper.splitQ s:, 7  KE4+      rArh)r8rCrDrErxr`r;rKrAr@rr6 sQ??*rArrF) classifierc|dn|}t|tjr5|r$|"t|ddvrt |St |St |drt|trKt|trt|trtd|zt|S|S)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(...) Nrr?)rrr;ziExpected cv as an integer, cross-validation object (from sklearn.model_selection) or an iterable. Got %s.) rrrrr)rhasattrr}rror)rCr?rs r@r.r.k sXjbB"g&''  c2226NNN"2&& &99  2w  &:b##6#6&"h'' :b#+>+> *,./  ""%%% IrArnneither)closedleftrbooleanz array-like)rrTrrstratifyT)prefer_skip_nested_validationcb t|}|dkrtdt|}t|d}t |||d\}} |dur>|tdt j| t j||| z nL|t} nt} | | ||} t| |d| \ t|d \ ttj fd |DS) a Split 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]] rz$At least one array required as inputg?r\FNz@Stratified train/test split is not implemented for shuffle=FalserS)r>r?c3XK|]$}t|t|fV%dSrb)r)rarrs r@r@z#train_test_split..= sM  DE^Au % %~a'>'> ?      rA)rrorrr^rNrOr+r'nextr;rrr from_iterable)rrTrrrarraysn_arraysrrr_r`CVClassrCrrs @@r@r-r- sl\6{{H1}}?@@@  FVAY''I-9jDOGV%  R  '""y'F"233  ,GG"G Wv' U U U288fQi88<<== t0E4HHKE4       IO       rA__test__ctj}tjdddt}|}dd|dzzdzz}t t |D]\}\}} t| tr|dt| } n|d|| } t| d kr| d d d z| d d z} |dkrY|t| zdksd| vr%| |t|}n| d|dz }| | |t| z }tjdi|d |} d d| dD} | S)afPretty 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, rnr|=iNi,z...irK z, c3@K|]}|dVdS)r|N)rstrip)rr5s r@r@z_pprint..w s,??ahhsmm??????rArK)rNget_printoptionsset_printoptionsrrsorteditemsrrr}rappendr~r;) paramsoffsetprinteroptions params_listthis_line_lengthline_seprrv this_reprliness r@_pprintrI s"!##G!rQ????&&KFaK3..Hvfllnn5566++ 6Aq a   2$%11c!fff-II$%11ggajjj1I y>>C  !$3$%/)DEE2BBI q55#i..0B66$):K:K""8,,,#&x==  ""4((( A% 9%%%C NN*""'""" GGK E II??U[[->->??? ? ?E LrAc|j}t|jd|j}t|}|tjurg}n0t d|jD}|jj}t}|D]}tj dt tj d5}t||d} | +t|dr|j|d} dddn #1swxYwYt#|r5|djtur! tjdtjdn$#tjdwxYw| ||<|dt+|t#| d S) Ndeprecated_originalcRg|]$}|jdk |j|jk|j%Sre)namer VAR_KEYWORD)rrws r@rz_build_repr.. s?   6V##!-(?(?(?(?(?rAalwaysT)recordr?r()r))r7getattrrxrobjectr parametersvaluesr8dictr5 simplefilter FutureWarningcatch_warningsrr?getrcategoryfilterspopr) r=clsinitinit_signatureargs class_namerr>wvalues r@rdrd{ s .C 3rs''''''''######$$$$$$))))))))  LKKKKKKKKK------777777------FFFFFFFFFF   *22222222D11111,111@!@!@!@!@!+w@!@!@!@!FLLLLL*,>LLL^Y>Y>Y>Y>Y>(*<Y>Y>Y>x[[[[[#w[[[[|]]]]] $j]]]@W+W+W+W+W+$jW+W+W+tD+D+D+D+D+jD+D+D+NKKKKK. KKK\QQQQQjQQQht+t+t+t+t+*,>t+t+t+nB+B+B+B+B+)+=B+B+B+Jh!h!h!h!h!(Gh!h!h!h!V? ? ? ? ? ,o? ? ? Di2i2i2i2i26i2i2i2Xt!t!t!t!t!)Wt!t!t!t!nf&f&f&f&f&+-=f&f&f&RO+O+O+O+O++-=O+O+O+dH+H+H+H+H+-H+H+H+VNNNNby&y&y&y&y&(y&y&y&x22222+222j@@@@@@F HZAi 8 8 8 HW%q$v > > >  HZAi 8 8 8 HW%q$v > > >  ((;!4(#'!(   @@@@%$@L*e,,,d////d%L%L%LPEEEEErA