ó cÂY]c@ sdZddlmZddlmZddlZddlmZmZddlm Z m Z ddl Z ddl m Z mZddlZdd lmZmZmZdd lmZmZdd lmZdd lmZdd lmZddlmZddlm Z m!Z!ddlm"Z#ddl$m%Z%ddddddddddddddd d!gZ&d"Z'd#Z(dee ƒfd$„ƒYZ)de)fd%„ƒYZ*de)fd&„ƒYZ+d'ee e)ƒfd(„ƒYZ,de,fd)„ƒYZ-de,fd*„ƒYZ.de,fd+„ƒYZ/d,e,fd-„ƒYZ0de)fd.„ƒYZ1de)fd/„ƒYZ2d0ee ƒfd1„ƒYZ3de3fd2„ƒYZ4de3fd3„ƒYZ5d4ee ƒfd5„ƒYZ6de6fd6„ƒYZ7de7fd7„ƒYZ8d8„Z9de6fd9„ƒYZ:d:„Z;d;„Z<de)fd<„ƒYZ=d=e)fd>„ƒYZ>d?de@d@„ZAdA„ZBe@eB_CdB„ZDdS(Cs The :mod:`sklearn.model_selection._split` module includes classes and functions to split the data based on a preset strategy. iÿÿÿÿ(tprint_function(tdivisionN(tchaint combinations(tceiltfloor(tABCMetatabstractmethodi(t indexabletcheck_random_statet safe_indexing(t _num_samplest column_or_1d(t check_array(ttype_of_target(twith_metaclass(tzip(t signaturetcomb(t _Iterable(t_pprinttBaseCrossValidatortKFoldt GroupKFoldtLeaveOneGroupOutt LeaveOneOuttLeavePGroupsOutt LeavePOuttRepeatedStratifiedKFoldt RepeatedKFoldt ShuffleSplittGroupShuffleSplittStratifiedKFoldtStratifiedShuffleSplittPredefinedSplitttrain_test_splittcheck_cvsYou should specify a value for 'n_splits' instead of relying on the default value. The default value will change from 3 to 5 in version 0.22.s‡You should specify a value for 'cv' instead of relying on the default value. The default value will change from 3 to 5 in version 0.22.cB skeZdZd„Zddd„Zdddd„Zdddd„Zedddd„ƒZ d„Z RS(suBase class for all cross-validators Implementations must define `_iter_test_masks` or `_iter_test_indices`. cC sdS(N((tself((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyt__init__Escc s|t|||ƒ\}}}tjt|ƒƒ}xE|j|||ƒD].}|tj|ƒ}||}||fVqFWdS(sìGenerate indices to split data into training and test set. Parameters ---------- X : array-like, 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 length n_samples The target variable for supervised learning problems. groups : array-like, with shape (n_samples,), optional 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(RtnptarangeR t_iter_test_maskst logical_not(R%tXtytgroupstindicest test_indext train_index((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pytsplitJs  cc sQxJ|j|||ƒD]3}tjt|ƒdtjƒ}t||<|VqWdS(sGenerates boolean masks corresponding to test sets. By default, delegates to _iter_test_indices(X, y, groups) tdtypeN(t_iter_test_indicesR'tzerosR tbooltTrue(R%R+R,R-R/t test_mask((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR)ks cC s t‚dS(s5Generates integer indices corresponding to test sets.N(tNotImplementedError(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR3uscC sdS(sAReturns the number of splitting iterations in the cross-validatorN((R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyt get_n_splitsytcC s t|ƒS(N(t _build_repr(R%((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyt__repr__}sN( t__name__t __module__t__doc__R&tNoneR1R)R3RR9R<(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR?s ! cB s,eZdZddd„Zddd„ZRS(sð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 -------- >>> 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 train_index, test_index in loo.split(X): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... print(X_train, X_test, y_train, y_test) TRAIN: [1] TEST: [0] [[3 4]] [[1 2]] [2] [1] TRAIN: [0] TEST: [1] [[1 2]] [[3 4]] [1] [2] 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. cC stt|ƒƒS(N(trangeR (R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR3¯scC s%|dkrtdƒ‚nt|ƒS(sAReturns the number of splitting iterations in the cross-validator Parameters ---------- X : array-like, 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. s%The 'X' parameter should not be None.N(R@t ValueErrorR (R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR9²s N(R=R>R?R@R3R9(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRs,cB s5eZdZd„Zddd„Zddd„ZRS(s¢Leave-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. Examples -------- >>> 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 train_index, test_index in lpo.split(X): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [2 3] TEST: [0 1] TRAIN: [1 3] TEST: [0 2] TRAIN: [1 2] TEST: [0 3] TRAIN: [0 3] TEST: [1 2] TRAIN: [0 2] TEST: [1 3] TRAIN: [0 1] TEST: [2 3] cC s ||_dS(N(tp(R%RC((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&÷scc s;x4ttt|ƒƒ|jƒD]}tj|ƒVqWdS(N(RRAR RCR'tarray(R%R+R,R-t combination((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR3ús%cC s=|dkrtdƒ‚nttt|ƒ|jdtƒƒS(sºReturns the number of splitting iterations in the cross-validator Parameters ---------- X : array-like, 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. s%The 'X' parameter should not be None.texactN(R@RBtintRR RCR6(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR9þs N(R=R>R?R&R@R3R9(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRËs* t _BaseKFoldcB s>eZdZed„ƒZddd„Zdddd„ZRS(s5Base class for KFold, GroupKFold, and StratifiedKFoldcC s§t|tjƒs1td|t|ƒfƒ‚nt|ƒ}|dkratdj|ƒƒ‚nt|tƒsˆtdj|ƒƒ‚n||_ ||_ ||_ dS(NsGThe number of folds must be of Integral type. %s of type %s was passed.isok-fold cross-validation requires at least one train/test split by setting n_splits=2 or more, got n_splits={0}.s&shuffle must be True or False; got {0}( t isinstancetnumberstIntegralRBttypeRGtformatR5t TypeErrortn_splitstshufflet random_state(R%RORPRQ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&s     cc s’t|||ƒ\}}}t|ƒ}|j|krTtdj|j|ƒƒ‚nx7tt|ƒj|||ƒD]\}}||fVqsWdS(sëGenerate indices to split data into training and test set. Parameters ---------- X : array-like, 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, shape (n_samples,) The target variable for supervised learning problems. groups : array-like, with shape (n_samples,), optional 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. s\Cannot have number of splits n_splits={0} greater than the number of samples: n_samples={1}.N(RR RORBRMtsuperRHR1(R%R+R,R-t n_samplesttrainttest((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1+s +cC s|jS(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 : object Always ignored, exists for compatibility. Returns ------- n_splits : int Returns the number of splitting iterations in the cross-validator. (RO(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR9NsN(R=R>R?RR&R@R1R9(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRHs#cB s/eZdZdedd„Zddd„ZRS(s3 K-Folds 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 `. Parameters ---------- n_splits : int, default=3 Number of folds. Must be at least 2. .. versionchanged:: 0.20 ``n_splits`` default value will change from 3 to 5 in v0.22. shuffle : boolean, optional Whether to shuffle the data before splitting into batches. random_state : int, RandomState instance or None, optional, default=None If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Used when ``shuffle`` == True. Examples -------- >>> 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) # doctest: +NORMALIZE_WHITESPACE KFold(n_splits=2, random_state=None, shuffle=False) >>> for train_index, test_index in kf.split(X): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [2 3] TEST: [0 1] TRAIN: [0 1] TEST: [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 group 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. twarncC sE|dkr%tjttƒd}ntt|ƒj|||ƒdS(NRVi(twarningsRVtNSPLIT_WARNINGt FutureWarningRRRR&(R%RORPRQ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&§s  c c s·t|ƒ}tj|ƒ}|jr=t|jƒj|ƒn|j}tj|||dtjƒ}|||c d7*d}x1|D])} ||| } } || | !V| }q†WdS(NR2ii( R R'R(RPR RQROtfullRG( R%R+R,R-RSR.ROt fold_sizestcurrentt fold_sizetstarttstop((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR3®s     N(R=R>R?tFalseR@R&R3(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRdsA cB s2eZdZdd„Zd„Zddd„ZRS(s K-fold iterator variant with non-overlapping groups. The same group will not appear in two different 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 distinct groups is approximately the same in each fold. Parameters ---------- n_splits : int, default=3 Number of folds. Must be at least 2. .. versionchanged:: 0.20 ``n_splits`` default value will change from 3 to 5 in v0.22. Examples -------- >>> from sklearn.model_selection import GroupKFold >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 3, 4]) >>> groups = np.array([0, 0, 2, 2]) >>> group_kfold = GroupKFold(n_splits=2) >>> group_kfold.get_n_splits(X, y, groups) 2 >>> print(group_kfold) GroupKFold(n_splits=2) >>> for train_index, test_index in group_kfold.split(X, y, groups): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... print(X_train, X_test, y_train, y_test) ... TRAIN: [0 1] TEST: [2 3] [[1 2] [3 4]] [[5 6] [7 8]] [1 2] [3 4] TRAIN: [2 3] TEST: [0 1] [[5 6] [7 8]] [[1 2] [3 4]] [3 4] [1 2] See also -------- LeaveOneGroupOut For splitting the data according to explicit domain-specific stratification of the dataset. RVcC sK|dkr%tjttƒd}ntt|ƒj|dtddƒdS(NRViRPRQ( RWRVRXRYRRRR&R`R@(R%RO((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&ïs   cc sk|dkrtdƒ‚nt|dtddƒ}tj|dtƒ\}}t|ƒ}|j|kr…td|j|fƒ‚ntj |ƒ}tj |ƒddd…}||}tj |jƒ}tj t|ƒƒ} xGt |ƒD]9\} } tj |ƒ} || c| 7<| | || R?R&R3R@R1(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR¾s0  %cB sGeZdZdedd„Zdd„Zddd„Zdd„ZRS(szStratified K-Folds 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 `. Parameters ---------- n_splits : int, default=3 Number of folds. Must be at least 2. .. versionchanged:: 0.20 ``n_splits`` default value will change from 3 to 5 in v0.22. shuffle : boolean, optional Whether to shuffle each class's samples before splitting into batches. random_state : int, RandomState instance or None, optional, default=None If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Used when ``shuffle`` == True. Examples -------- >>> 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) # doctest: +NORMALIZE_WHITESPACE StratifiedKFold(n_splits=2, random_state=None, shuffle=False) >>> for train_index, test_index in skf.split(X, y): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [1 3] TEST: [0 2] TRAIN: [0 2] TEST: [1 3] Notes ----- Train and test sizes may be different in each fold, with a difference of at most ``n_classes``. See also -------- RepeatedStratifiedKFold: Repeats Stratified K-Fold n times. RVcC sE|dkr%tjttƒd}ntt|ƒj|||ƒdS(NRVi(RWRVRXRYRRR R&(R%RORPRQ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&ms  cC sút|jƒ}tj|ƒ}t|ƒ}d }||krWtdj||ƒƒ‚nt|ƒ}|jd}tj |dt ƒ\}}tj |ƒ} tj | ƒ} tj |j| kƒr×td|jƒ‚n|j| krtjd| |jftƒng| D]B} t|jd|jd |ƒjtjt| |jƒƒƒ^q } tj|d tjƒ} x†tt| ŒƒD]r\}}xct||ƒD]R\}\}}| ||k}||t|ƒk}|||<|| ||kR?R`R@R&R‹R)R1(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR 6s 5 4tTimeSeriesSplitcB s,eZdZddd„Zddd„ZRS(s€Time 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 `. Parameters ---------- n_splits : int, default=3 Number of splits. Must be at least 2. .. versionchanged:: 0.20 ``n_splits`` default value will change from 3 to 5 in v0.22. max_train_size : int, optional Maximum size for a single training set. Examples -------- >>> from sklearn.model_selection import TimeSeriesSplit >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([1, 2, 3, 4, 5, 6]) >>> tscv = TimeSeriesSplit(n_splits=5) >>> print(tscv) # doctest: +NORMALIZE_WHITESPACE TimeSeriesSplit(max_train_size=None, n_splits=5) >>> for train_index, test_index in tscv.split(X): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [0] TEST: [1] TRAIN: [0 1] TEST: [2] TRAIN: [0 1 2] TEST: [3] TRAIN: [0 1 2 3] TEST: [4] TRAIN: [0 1 2 3 4] TEST: [5] 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)``, where ``n_samples`` is the number of samples. RVcC sT|dkr%tjttƒd}ntt|ƒj|dtddƒ||_ dS(NRViRPRQ( RWRVRXRYRRRR&R`R@tmax_train_size(R%RORŽ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&s  c c st|||ƒ\}}}t|ƒ}|j}|d}||kratdj||ƒƒ‚ntj|ƒ}||}t|||||ƒ} xg| D]_} |jrà|j| krà|| |j| !|| | |!fVq›|| || | |!fVq›WdS(s Generate indices to split data into training and test set. Parameters ---------- X : array-like, 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, shape (n_samples,) Always ignored, exists for compatibility. groups : array-like, with 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. isICannot have number of folds ={0} greater than the number of samples: {1}.N( RR RORBRMR'R(RARŽ( R%R+R,R-RSROtn_foldsR.t test_sizet test_startst test_start((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1s&       N(R=R>R?R@R&R1(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRÒs4 cB s8eZdZd„Zdddd„Zddd„ZRS(s8Leave One Group 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. Read more in the :ref:`User Guide `. Examples -------- >>> 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 train_index, test_index in logo.split(X, y, groups): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... print(X_train, X_test, y_train, y_test) TRAIN: [2 3] TEST: [0 1] [[5 6] [7 8]] [[1 2] [3 4]] [1 2] [1 2] TRAIN: [0 1] TEST: [2 3] [[1 2] [3 4]] [[5 6] [7 8]] [1 2] [1 2] cc s|dkrtdƒ‚nt|dtdtddƒ}tj|ƒ}t|ƒdkrmtd|ƒ‚nx|D]}||kVqtWdS(Ns*The 'groups' parameter should not be None.tcopyRaR2iscThe groups parameter contains fewer than 2 unique groups (%s). LeaveOneGroupOut expects at least 2.(R@RBR R6R`R'RcRd(R%R+R,R-RjRŒ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR)fs   cC sF|dkrtdƒ‚nt|dtddƒ}ttj|ƒƒS(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, with 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. s*The 'groups' parameter should not be None.RaR2N(R@RBR R`RdR'Rc(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR9ss cC stt|ƒj|||ƒS(sìGenerate indices to split data into training and test set. Parameters ---------- X : array-like, 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 length n_samples, optional The target variable for supervised learning problems. groups : array-like, with 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. (RRRR1(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1ŽsN(R=R>R?R)R@R9R1(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR=s' cB sAeZdZd„Zd„Zdddd„Zddd„ZRS(s,Leave 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 -------- >>> 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 train_index, test_index in lpgo.split(X, y, groups): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... print(X_train, X_test, y_train, y_test) TRAIN: [2] TEST: [0 1] [[5 6]] [[1 2] [3 4]] [1] [1 2] TRAIN: [1] TEST: [0 2] [[3 4]] [[1 2] [5 6]] [2] [1 1] TRAIN: [0] TEST: [1 2] [[1 2]] [[3 4] [5 6]] [1] [2 1] See also -------- GroupKFold: K-fold iterator variant with non-overlapping groups. cC s ||_dS(N(Rk(R%Rk((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&àsc c s|dkrtdƒ‚nt|dtdtddƒ}tj|ƒ}|jt|ƒkrƒtd|j||jdfƒ‚nt t t|ƒƒ|jƒ}x_|D]W}tj t |ƒdtj ƒ}x+|tj|ƒD]}t|||kR?R&R)R@R9R1(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR©s 5  t_RepeatedSplitscB s>eZdZddd„Zddd„Zdddd„ZRS(sRepeated 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, optional, default=None If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. **cvargs : additional params Constructor parameters for cv. Must not contain random_state and shuffle. i c s˜t|tjtjfƒs*tdƒ‚n|dkrEtdƒ‚nt‡fd†dDƒƒrptdƒ‚n||_||_||_ ˆ|_ dS( Ns/Number of repetitions must be of Integral type.is-Number of repetitions must be greater than 0.c3 s|]}|ˆkVqdS(N((t.0tkey(tcvargs(s=lib/python2.7/site-packages/sklearn/model_selection/_split.pys JsRQRPs0cvargs must not contain random_state or shuffle.(RQRP( RIR'tintegerRJRKRBtanytcvt n_repeatsRQR™(R%RœRRQR™((R™s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&Cs     c c s‚|j}t|jƒ}xct|ƒD]U}|jd|dt|j}x.|j|||ƒD]\}} || fVq_Wq%WdS(síGenerates indices to split data into training and test set. Parameters ---------- X : array-like, 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 length n_samples The target variable for supervised learning problems. groups : array-like, with shape (n_samples,), optional 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. RQRPN(RR RQRARœR6R™R1( R%R+R,R-RR{tidxRœR0R/((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1Ss  "cC sGt|jƒ}|jd|dt|j}|j|||ƒ|jS(sº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, with shape (n_samples,), optional 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. RQRP(R RQRœR6R™R9R(R%R+R,R-R{Rœ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR9ts N(R=R>R?R@R&R1R9(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR–+s!cB s eZdZdddd„ZRS(s?Repeated 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, optional, default=None If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Examples -------- >>> 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) >>> for train_index, test_index in rkf.split(X): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... TRAIN: [0 1] TEST: [2 3] TRAIN: [2 3] TEST: [0 1] TRAIN: [1 2] TEST: [0 3] TRAIN: [0 3] TEST: [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. ii cC s&tt|ƒjt||d|ƒdS(NRO(RRRR&R(R%RORRQ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&¿sN(R=R>R?R@R&(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRs.cB s eZdZdddd„ZRS(s«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 : None, int or RandomState, default=None Random state to be used to generate random state for each repetition. Examples -------- >>> 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) >>> for train_index, test_index in rskf.split(X, y): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] ... TRAIN: [1 2] TEST: [0 3] TRAIN: [0 3] TEST: [1 2] TRAIN: [1 3] TEST: [0 2] TRAIN: [0 2] TEST: [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. ii cC s&tt|ƒjt||d|ƒdS(NRO(RRRR&R (R%RORRQ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&ósN(R=R>R?R@R&(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRÄs.tBaseShuffleSplitcB sbeZdZddddd„Zddd„Zeddd„ƒZdddd„Zd„Z RS( s6Base class for ShuffleSplit and StratifiedShuffleSpliti tdefaultcC s5t||ƒ||_||_||_||_dS(N(t_validate_shuffle_split_initRORt train_sizeRQ(R%RORR¢RQ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&ûs     cc sPt|||ƒ\}}}x.|j|||ƒD]\}}||fVq1WdS(s»Generate indices to split data into training and test set. Parameters ---------- X : array-like, 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, shape (n_samples,) The target variable for supervised learning problems. groups : array-like, with shape (n_samples,), optional 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(Rt _iter_indices(R%R+R,R-RTRU((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1s"cC sdS(sGenerate (train, test) indicesN((R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR£%R:cC s|jS(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 : object Always ignored, exists for compatibility. Returns ------- n_splits : int Returns the number of splitting iterations in the cross-validator. (RO(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR9)scC s t|ƒS(N(R;(R%((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR<>sN( R=R>R?R@R&R1RR£R9R<(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRŸøs  "cB seZdZddd„ZRS(s 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 all folds will be different, although this is still very likely for sizeable datasets. Read more in the :ref:`User Guide `. Parameters ---------- n_splits : int, default 10 Number of re-shuffling & splitting iterations. test_size : float, int, None, default=0.1 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. By default (the parameter is unspecified), the value is set to 0.1. The default will change in version 0.21. It will remain 0.1 only if ``train_size`` is unspecified, otherwise it will complement the specified ``train_size``. train_size : float, int, or None, 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, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Examples -------- >>> 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 train_index, test_index in rs.split(X): ... print("TRAIN:", train_index, "TEST:", test_index) ... # doctest: +ELLIPSIS TRAIN: [1 3 0 4] TEST: [5 2] TRAIN: [4 0 2 5] TEST: [1 3] TRAIN: [1 2 4 0] TEST: [3 5] TRAIN: [3 4 1 0] TEST: [5 2] TRAIN: [3 5 1 0] TEST: [2 4] >>> rs = ShuffleSplit(n_splits=5, train_size=0.5, test_size=.25, ... random_state=0) >>> for train_index, test_index in rs.split(X): ... print("TRAIN:", train_index, "TEST:", test_index) ... # doctest: +ELLIPSIS TRAIN: [1 3 0] TEST: [5 2] TRAIN: [4 0 2] TEST: [1 3] TRAIN: [1 2 4] TEST: [3 5] TRAIN: [3 4 1] TEST: [5 2] TRAIN: [3 5 1] TEST: [2 4] c c sŒt|ƒ}t||j|jƒ\}}t|jƒ}xLt|jƒD];}|j|ƒ} | | } | |||!} | | fVqIWdS(N( R t_validate_shuffle_splitRR¢R RQRAROt permutation( R%R+R,R-RStn_traintn_testR{RŒR¥tind_testt ind_train((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR£†s  N(R=R>R?R@R£(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRBsBcB s;eZdZddddd„Zd„Zddd„ZRS(s 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 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)``. Note: The parameters ``test_size`` and ``train_size`` refer to groups, and not to samples, as in ShuffleSplit. Parameters ---------- n_splits : int (default 5) Number of re-shuffling & splitting iterations. test_size : float, int, None, optional 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. By default, the value is set to 0.2. The default will change in version 0.21. It will remain 0.2 only if ``train_size`` is unspecified, otherwise it will complement the specified ``train_size``. train_size : float, int, or None, default is 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, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. iR c C sc|dkr4|dk r+tjdtƒnd}ntt|ƒjd|d|d|d|ƒdS(NR sYFrom version 0.21, test_size will always complement train_size unless both are specified.gš™™™™™É?RORR¢RQ(R@RWRVRYRRRR&(R%RORR¢RQ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&Çs     c c s¿|dkrtdƒ‚nt|dtddƒ}tj|dtƒ\}}xjtt|ƒj d|ƒD]M\}}tj tj ||ƒƒ}tj tj ||ƒƒ} || fVqjWdS(Ns*The 'groups' parameter should not be None.RaR2RbR+( R@RBR R`R'RcR6RRRR£t flatnonzerotin1d( R%R+R,R-tclassest group_indicest group_traint group_testRTRU((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR£×s "cC stt|ƒj|||ƒS(s»Generate indices to split data into training and test set. Parameters ---------- X : array-like, 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, shape (n_samples,), optional The target variable for supervised learning problems. groups : array-like, with 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. (RRRR1(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1æsN(R=R>R?R@R&R£R1(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR”s 1   c C st|ƒ}|||jƒ}tj|ƒ}t||jƒƒ}|dkr||}tjtj|ƒƒddd…}xƒ|D]x}tj||kƒ\} tt | ƒ|ƒ} |j | d| dt ƒ} || cd7<|| 8}|dkr‡Pq‡q‡Wn|j tjƒS(söComputes approximate mode of multivariate hypergeometric. This is an approximation to the mode of the multivariate hypergeometric given by class_counts and n_draws. It shouldn't be off by more than one. It is the mostly likely outcome of drawing n_draws many samples from the population given by class_counts. Parameters ---------- class_counts : ndarray of int Population per class. n_draws : int Number of draws (samples to draw) from the overall population. rng : random state Used to break ties. Returns ------- sampled_classes : ndarray of int Number of samples drawn from each class. np.sum(sampled_classes) == n_draws Examples -------- >>> from sklearn.model_selection._split import _approximate_mode >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0) array([2, 1]) >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0) array([3, 1]) >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), ... n_draws=2, rng=0) array([0, 1, 1, 0]) >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), ... n_draws=2, rng=42) array([1, 1, 0, 0]) iNiÿÿÿÿtsizetreplacei( R tsumR'RRGtsortRcRiRwRdtchoiceR`tastype( t class_countstn_drawsR{t continuoustflooredt need_to_addt remaindertvaluestvaluetindstadd_now((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyt_approximate_modes '   %    cB s;eZdZddddd„Zdd„Zdd„ZRS(s– Stratified ShuffleSplit cross-validator Provides train/test indices to split data in train/test sets. This cross-validation object is a merge of StratifiedKFold and ShuffleSplit, which returns stratified randomized folds. The folds are made by preserving the percentage of samples for each class. Note: like the ShuffleSplit strategy, stratified random splits do not guarantee that all folds will be different, although this is still very likely for sizeable datasets. Read more in the :ref:`User Guide `. Parameters ---------- n_splits : int, default 10 Number of re-shuffling & splitting iterations. test_size : float, int, None, optional 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. By default, the value is set to 0.1. The default will change in version 0.21. It will remain 0.1 only if ``train_size`` is unspecified, otherwise it will complement the specified ``train_size``. train_size : float, int, or None, default is 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, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Examples -------- >>> 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) # doctest: +ELLIPSIS StratifiedShuffleSplit(n_splits=5, random_state=0, ...) >>> for train_index, test_index in sss.split(X, y): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [5 2 3] TEST: [4 1 0] TRAIN: [5 1 4] TEST: [0 2 3] TRAIN: [5 0 2] TEST: [4 3 1] TRAIN: [4 1 0] TEST: [2 3 5] TRAIN: [0 5 1] TEST: [3 4 2] i R cC s#tt|ƒj||||ƒdS(N(RRR!R&(R%RORR¢RQ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&‰scc sgt|ƒ}t|dtddƒ}t||j|jƒ\}}|jdkrˆtj g|D]}dj |j dƒƒ^q^ƒ}ntj |dt ƒ\}} |jd} tj| ƒ} tj| ƒdkrãtdƒ‚n|| krtd || fƒ‚n|| kr-td || fƒ‚ntjtj| d d ƒtj| ƒd ƒ} t|jƒ} xöt|jƒD]å}t| || ƒ}| |}t||| ƒ}g}g}xyt| ƒD]k}| j| |ƒ}| |j|ddƒ}|j||| ƒ|j|||||||!ƒqÇW| j|ƒ}| j|ƒ}||fVqzWdS(NRaR2it tstrRbis…The 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.sLThe train_size = %d should be greater or equal to the number of classes = %dsKThe test_size = %d should be greater or equal to the number of classes = %dtkindt mergesortiÿÿÿÿtmodetclip(R R R`R@R¤RR¢tndimR'RDtjoinRµRcR6RvReRwRBR1RftcumsumR RQRARORÀR¥ttaketextend(R%R+R,R-RSR¦R§trowR¬t y_indicest n_classesR¶t class_indicesR{Rˆtn_itclass_counts_remainingtt_iRTRURŒR¥tperm_indices_class_i((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR£ŽsF  7     (cC s4t|dtddƒ}tt|ƒj|||ƒS(sgGenerate indices to split data into training and test set. Parameters ---------- X : array-like, 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, 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. RaR2N(R R`R@RRR!R1(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1Ês"N(R=R>R?R@R&R£R1(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR!Ks <   `. Parameters ---------- test_fold : array-like, 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 -------- >>> 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) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS PredefinedSplit(test_fold=array([ 0, 1, -1, 1])) >>> for train_index, test_index in ps.split(): ... print("TRAIN:", train_index, "TEST:", test_index) ... X_train, X_test = X[train_index], X[test_index] ... y_train, y_test = y[train_index], y[test_index] TRAIN: [1 2 3] TEST: [0] TRAIN: [0 2] TEST: [1 3] cC s_tj|dtjƒ|_t|jƒ|_tj|jƒ|_|j|jdk|_dS(NR2iÿÿÿÿ(R'RDRGt test_foldR Rct unique_folds(R%RÕ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&jscc s[tjt|jƒƒ}x<|jƒD].}|tj|ƒ}||}||fVq%WdS(sGenerate 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. N(R'R(RdRÕR)R*(R%R+R,R-tindR/R0((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1ps  cc sdx]|jD]R}tj|j|kƒd}tjt|jƒdtjƒ}t||<|Vq WdS(s3Generates boolean masks corresponding to test sets.iR2N(RÖR'RiRÕR4RdR5R6(R%RrR/R7((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR)Œs ! cC s t|jƒS(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 : object Always ignored, exists for compatibility. Returns ------- n_splits : int Returns the number of splitting iterations in the cross-validator. (RdRÖ(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR9”sN(R=R>R?R&R@R1R)R9(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR"Gs !  t_CVIterableWrappercB s;eZdZd„Zdddd„Zdddd„ZRS(s5Wrapper class for old style cv objects and iterables.cC st|ƒ|_dS(N(tlistRœ(R%Rœ((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR&¬scC s t|jƒS(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 : object Always ignored, exists for compatibility. Returns ------- n_splits : int Returns the number of splitting iterations in the cross-validator. (RdRœ(R%R+R,R-((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR9¯scc s)x"|jD]\}}||fVq WdS(sGenerate 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. N(Rœ(R%R+R,R-RTRU((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR1ÄsN(R=R>R?R&R@R9R1(((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyRتs RVcC sÝ|dks|dkr1tjttƒd}nt|tjƒr~|rq|dk rqt|ƒdkrqt |ƒSt |ƒSnt |dƒ st|t ƒrÙt|t ƒ s¼t|t ƒrÏtd|ƒ‚nt|ƒS|S( s4Input checker utility for building a cross-validator Parameters ---------- cv : int, cross-validation generator or an iterable, optional Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 3-fold cross-validation, - integer, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (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.20 ``cv`` default value will change from 3-fold to 5-fold in v0.22. y : array-like, optional The target variable for supervised learning problems. classifier : boolean, optional, 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. RViRsRtR1siExpected cv as an integer, cross-validation object (from sklearn.model_selection) or an iterable. Got %s.N(RsRt(R@RWRVt CV_WARNINGRYRIRJRKRR RthasattrRÂtIterableRBRØ(RœR,t classifier((s=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR$Þs%     c  süt|ƒ}|dkr'tdƒ‚n|jddƒ}|jddƒ}|jddƒ}|jddƒ}|jdtƒ}|r td t|ƒƒ‚n|dkrÔd}|dk rÔtjd t ƒqÔn|dkrõ|dkrõd }nt |Œ}|t krx|dk r(td ƒ‚nt |dƒ}t |||ƒ\} } tj| ƒ‰tj| | | ƒ‰n^|dk rt} nt} | d|d|d|ƒ} t| jd |dd|ƒƒ\‰‰ttj‡‡fd†|DƒƒƒS(sõ Split arrays or matrices into random train and test subsets Quick utility that wraps input validation and ``next(ShuffleSplit().split(X, y))`` and application to input data into a single call for splitting (and optionally subsampling) data in a oneliner. 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, int or None, optional (default=0.25) 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. By default, the value is set to 0.25. The default will change in version 0.21. It will remain 0.25 only if ``train_size`` is unspecified, otherwise it will complement the specified ``train_size``. train_size : float, int, or None, (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, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. shuffle : boolean, optional (default=True) Whether or not to shuffle the data before splitting. If shuffle=False then stratify must be None. stratify : array-like or None (default=None) If not None, data is split in a stratified fashion, using this as the class labels. 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]] is$At least one array required as inputRR R¢RQtstratifyRPsInvalid parameters passed: %ssYFrom version 0.21, test_size will always complement train_size unless both are specified.gÐ?s@Stratified train/test split is not implemented for shuffle=FalseR+R,c3 s-|]#}t|ˆƒt|ˆƒfVqdS(N(R (R—ta(RURT(s=lib/python2.7/site-packages/sklearn/model_selection/_split.pys ¢sN(RdRBtpopR@R6RNRÂRWRVRYRR`R R¤R'R(R!RtnextR1RÙRt from_iterable( tarraystoptionstn_arraysRR¢RQRÞRPRSR¦R§tCVClassRœ((RURTs=lib/python2.7/site-packages/sklearn/model_selection/_split.pyR#sHX                (c C s[|j}t|jd|jƒ}t|ƒ}|tjkrEg}nLtg|jjƒD]0}|jdkrX|j |j krX|j^qXƒ}|jj }t ƒ}x’|D]Š}t jdtƒzVt jdtƒ} t||dƒ} WdQXt| ƒr| djtkrw­nWdt jjdƒX| ||sz     BJGRZxœkl‚e44JRs D¥ + ,c4: