Submit
Path:
~
/
/
proc
/
thread-self
/
root
/
opt
/
alt
/
python35
/
lib64
/
python3.5
/
site-packages
/
sklearn
/
__pycache__
/
File Content:
cross_validation.cpython-35.pyc
��(X� � @ sA d Z d d l m Z d d l m Z d d l Z d d l m Z m Z d d l m Z m Z m Z d d l Z d d l Z d d l m Z m Z d d l Z d d l j Z d d l m Z m Z d d l m Z m Z m Z d d l m Z m Z m Z d d l! m" Z" d d l# m$ Z$ d d l% m& Z& m' Z' m( Z( d d l) m* Z* d d l+ m, Z, d d l- m. Z. d d l/ m0 Z0 d d l1 m2 Z3 d d l4 m5 Z5 e j6 d e7 � d d d d d d d d d d d d! d" d# d$ d% g Z8 Gd& d' � d' e* e � � Z9 Gd( d � d e9 � Z: Gd) d � d e9 � Z; Gd* d+ � d+ e* e e9 � � Z< Gd, d � d e< � Z= Gd- d � d e< � Z> Gd. d � d e< � Z? Gd/ d � d e9 � Z@ Gd0 d � d e9 � ZA Gd1 d2 � d2 e* e � � ZB Gd3 d � d eB � ZC d4 d5 � ZD d6 d7 � ZE Gd8 d � d eB � ZF Gd9 d � d e9 � ZG Gd: d � d eC � ZH d; d< � ZI d d d d d d= d> d# � ZJ d? d@ � ZK dA dB � ZL d d d d d d d= dC d" � ZM dD dD dE dF dG � ZN d dH dI � ZO dJ dK � ZP dL dM � ZQ dN dO � ZR d d dD dP d! � ZS d dQ d d d d d dR d$ � ZT dD eT _U dS d% � ZV dD eV _U d S)Tzq The :mod:`sklearn.cross_validation` module includes utilities for cross- validation and performance evaluation. � )�print_function)�divisionN)�chain� combinations)�ceil�floor� factorial)�ABCMeta�abstractmethod� )� is_classifier�clone)� indexable�check_random_state� safe_indexing)� _is_arraylike� _num_samples� column_or_1d)�type_of_target)�choice)�Parallel�delayed�logger)�with_metaclass)�zip)� check_scoring)�bincount)�Kernel)�FitFailedWarninga This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.�KFold� LabelKFold�LeaveOneLabelOut� LeaveOneOut�LeavePLabelOut� LeavePOut� ShuffleSplit�StratifiedKFold�StratifiedShuffleSplit�PredefinedSplit�LabelShuffleSplit�check_cv�cross_val_score�cross_val_predict�permutation_test_score�train_test_splitc @ sR e Z d Z d Z d d � Z d d � Z d d � Z d d � Z d d � Z d S) �_PartitionIteratorz�Base class for CV iterators where train_mask = ~test_mask Implementations must define `_iter_test_masks` or `_iter_test_indices`. Parameters ---------- n : int Total number of elements in dataset. c C sG t | t | � � t j d � j k r4 t d � � t | � | _ d S)N�fzn must be an integer)�abs�int�np�finfo�eps� ValueError�n)�selfr7 � r9 �/cross_validation.py�__init__L s ( z_PartitionIterator.__init__c c s[ t j | j � } xB | j � D]4 } t j | � } | | } | | } | | f Vq Wd S)N)r3 �aranger7 �_iter_test_masksZ logical_not)r8 �ind� test_indexZ train_indexr9 r9 r: �__iter__Q s z_PartitionIterator.__iter__c c s6 x/ | j � D]! } | j � } d | | <| Vq Wd S)zsGenerates boolean masks corresponding to test sets. By default, delegates to _iter_test_indices() TN)�_iter_test_indices� _empty_mask)r8 r? Z test_maskr9 r9 r: r= [ s z#_PartitionIterator._iter_test_masksc C s t � d S)z5Generates integer indices corresponding to test sets.N)�NotImplementedError)r8 r9 r9 r: rA e s z%_PartitionIterator._iter_test_indicesc C s t j | j d t j �S)N�dtype)r3 �zerosr7 �bool)r8 r9 r9 r: rB i s z _PartitionIterator._empty_maskN) �__name__� __module__� __qualname__�__doc__r; r@ r= rA rB r9 r9 r9 r: r/ A s r/ c @ s: e Z d Z d Z d d � Z d d � Z d d � Z d S) r" a_ Leave-One-Out cross validation iterator. .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.LeaveOneOut` instead. 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(n)`` is equivalent to ``KFold(n, n_folds=n)`` and ``LeavePOut(n, p=1)``. 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 KFold, StratifiedKFold or ShuffleSplit. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- n : int Total number of elements in dataset. Examples -------- >>> from sklearn import cross_validation >>> X = np.array([[1, 2], [3, 4]]) >>> y = np.array([1, 2]) >>> loo = cross_validation.LeaveOneOut(2) >>> len(loo) 2 >>> print(loo) sklearn.cross_validation.LeaveOneOut(n=2) >>> for train_index, test_index in loo: ... 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 -------- LeaveOneLabelOut for splitting the data according to explicit, domain-specific stratification of the dataset. c C s t | j � S)N)�ranger7 )r8 r9 r9 r: rA � s z LeaveOneOut._iter_test_indicesc C s d | j j | j j | j f S)Nz %s.%s(n=%i))� __class__rH rG r7 )r8 r9 r9 r: �__repr__� s zLeaveOneOut.__repr__c C s | j S)N)r7 )r8 r9 r9 r: �__len__� s zLeaveOneOut.__len__N)rG rH rI rJ rA rM rN r9 r9 r9 r: r" m s 2 c sL e Z d Z d Z � f d d � Z d d � Z d d � Z d d � Z � S) r$ a` Leave-P-Out cross validation iterator .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.LeavePOut` instead. 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(n, p)`` is NOT equivalent to ``KFold(n, n_folds=n // 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 KFold, StratifiedKFold or ShuffleSplit. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- n : int Total number of elements in dataset. p : int Size of the test sets. Examples -------- >>> from sklearn import cross_validation >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 3, 4]) >>> lpo = cross_validation.LeavePOut(4, 2) >>> len(lpo) 6 >>> print(lpo) sklearn.cross_validation.LeavePOut(n=4, p=2) >>> for train_index, test_index in lpo: ... 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] c s# t t | � j | � | | _ d S)N)�superr$ r; �p)r8 r7 rP )rL r9 r: r; � s zLeavePOut.__init__c c s8 x1 t t | j � | j � D] } t j | � Vq Wd S)N)r rK r7 rP r3 �array)r8 �combr9 r9 r: rA � s "z LeavePOut._iter_test_indicesc C s& d | j j | j j | j | j f S)Nz%s.%s(n=%i, p=%i))rL rH rG r7 rP )r8 r9 r9 r: rM � s zLeavePOut.__repr__c C s4 t t | j � t | j | j � t | j � � S)N)r2 r r7 rP )r8 r9 r9 r: rN � s zLeavePOut.__len__)rG rH rI rJ r; rA rM rN r9 r9 )rL r: r$ � s 0 c s. e Z d Z d Z e � f d d � � Z � S)� _BaseKFoldz'Base class to validate KFold approachesc s� t t | � j | � t | t | � � t j d � j k rJ t d � � t | � | _ } | d k r~ t d j | � � � | | j k r� t d j | | � � � t | t � s� t d j | � � � | | _ | | _ d S)Nr0 zn_folds must be an integerr zok-fold cross validation requires at least one train / test split by setting n_folds=2 or more, got n_folds={0}.zPCannot have number of folds n_folds={0} greater than the number of samples: {1}.z&shuffle must be True or False; got {0})rO rS r; r1 r2 r3 r4 r5 r6 �n_folds�formatr7 � isinstancerF � TypeError�shuffle� random_state)r8 r7 rT rX rY )rL r9 r: r; � s" ( z_BaseKFold.__init__)rG rH rI rJ r r; r9 r9 )rL r: rS � s rS c sU e Z d Z d Z d d d � f d d � Z d d � Z d d � Z d d � Z � S) r a� K-Folds cross validation iterator. .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.KFold` instead. 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 as a validation set once while the k - 1 remaining fold(s) form the training set. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- n : int Total number of elements. n_folds : int, default=3 Number of folds. Must be at least 2. shuffle : boolean, optional Whether to shuffle the data before splitting into batches. random_state : None, int or RandomState When shuffle=True, pseudo-random number generator state used for shuffling. If None, use default numpy RNG for shuffling. Examples -------- >>> from sklearn.cross_validation import KFold >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([1, 2, 3, 4]) >>> kf = KFold(4, n_folds=2) >>> len(kf) 2 >>> print(kf) # doctest: +NORMALIZE_WHITESPACE sklearn.cross_validation.KFold(n=4, n_folds=2, shuffle=False, random_state=None) >>> for train_index, test_index in kf: ... 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 % n_folds folds have size n // n_folds + 1, other folds have size n // n_folds. See also -------- StratifiedKFold take label information into account to avoid building folds with imbalanced class distributions (for binary or multiclass classification tasks). LabelKFold: K-fold iterator variant with non-overlapping labels. � FNc sZ t t | � j | | | | � t j | � | _ | rV t | j � } | j | j � d S)N) rO r r; r3 r< �idxsr rY rX )r8 r7 rT rX rY �rng)rL r9 r: r; P s zKFold.__init__c c s� | j } | j } | | t j | d t j �} | d | | � d 7<d } x7 | D]/ } | | | } } | j | | � V| } qW Wd S)NrD r r )r7 rT r3 Zonesr2 r[ )r8 r7 rT Z fold_sizes�currentZ fold_size�start�stopr9 r9 r: rA X s zKFold._iter_test_indicesc C s2 d | j j | j j | j | j | j | j f S)Nz4%s.%s(n=%i, n_folds=%i, shuffle=%s, random_state=%s))rL rH rG r7 rT rX rY )r8 r9 r9 r: rM c s zKFold.__repr__c C s | j S)N)rT )r8 r9 r9 r: rN m s z KFold.__len__)rG rH rI rJ r; rA rM rN r9 r9 )rL r: r s < c sO e Z d Z d Z d � f d d � Z d d � Z d d � Z d d � Z � S) r a� K-fold iterator variant with non-overlapping labels. .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.GroupKFold` instead. The same label will not appear in two different folds (the number of distinct labels has to be at least equal to the number of folds). The folds are approximately balanced in the sense that the number of distinct labels is approximately the same in each fold. .. versionadded:: 0.17 Parameters ---------- labels : array-like with shape (n_samples, ) Contains a label for each sample. The folds are built so that the same label does not appear in two different folds. n_folds : int, default=3 Number of folds. Must be at least 2. Examples -------- >>> from sklearn.cross_validation import LabelKFold >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 3, 4]) >>> labels = np.array([0, 0, 2, 2]) >>> label_kfold = LabelKFold(labels, n_folds=2) >>> len(label_kfold) 2 >>> print(label_kfold) sklearn.cross_validation.LabelKFold(n_labels=4, n_folds=2) >>> for train_index, test_index in label_kfold: ... 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 -------- LeaveOneLabelOut for splitting the data according to explicit, domain-specific stratification of the dataset. rZ c s( t t | � j t | � | d d d d �t j | d d �\ } } t | � } | | k rv t d j | | � � � t j | � } t j | � d d d � } | | } t j | � } t j t | � � } xE t | � D]7 \ } } t j | � } | | | 7<| | | | <q� W| | | _ d S) NrX FrY �return_inverseTzOCannot have number of folds n_folds={0} greater than the number of labels: {1}.r ���)rO r r; �lenr3 �uniquer6 rU r ZargsortrE � enumerateZargminr[ ) r8 �labelsrT � unique_labelsZn_labelsZn_samples_per_label�indicesZn_samples_per_foldZ label_to_foldZ label_indexZweightZ lightest_fold)rL r9 r: r; � s& zLabelKFold.__init__c c s9 x2 t | j � D]! } t j | j | k � d Vq Wd S)Nr )rK rT r3 �wherer[ )r8 r0 r9 r9 r: rA � s z LabelKFold._iter_test_indicesc C s( d j | j j | j j | j | j � S)Nz"{0}.{1}(n_labels={2}, n_folds={3}))rU rL rH rG r7 rT )r8 r9 r9 r: rM � s zLabelKFold.__repr__c C s | j S)N)rT )r8 r9 r9 r: rN � s zLabelKFold.__len__)rG rH rI rJ r; rA rM rN r9 r9 )rL r: r q s 7" c sU e Z d Z d Z d d d � f d d � Z d d � Z d d � Z d d � Z � S) r& a� Stratified K-Folds cross validation iterator .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.StratifiedKFold` instead. 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 <cross_validation>`. Parameters ---------- y : array-like, [n_samples] Samples to split in K folds. n_folds : int, default=3 Number of folds. Must be at least 2. shuffle : boolean, optional Whether to shuffle each stratification of the data before splitting into batches. random_state : None, int or RandomState When shuffle=True, pseudo-random number generator state used for shuffling. If None, use default numpy RNG for shuffling. Examples -------- >>> from sklearn.cross_validation import StratifiedKFold >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> skf = StratifiedKFold(y, n_folds=2) >>> len(skf) 2 >>> print(skf) # doctest: +NORMALIZE_WHITESPACE sklearn.cross_validation.StratifiedKFold(labels=[0 0 1 1], n_folds=2, shuffle=False, random_state=None) >>> for train_index, test_index in skf: ... 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 ----- All the folds have size trunc(n_samples / n_folds), the last one has the complementary. See also -------- LabelKFold: K-fold iterator variant with non-overlapping labels. rZ FNc s� t t � � j t | � | | | � t j | � } | j d } t j | d d �\ } } t | � } t j | � } t j � j | k � r� t d � j � � � j | k r� t j d | � j f t � � j r� t � j � � n � j � � � f d d � | D� } t j | d t j �} x� t t | � � D]r \ } } xc t | | � D]R \ } \ } } | | | k } | | t | � k } | | | <| | | | k <qUWq9W| � _ | � _ d S) Nr r` Tz?All the n_labels for individual classes are less than %d folds.z�The least populated class in y has only %d members, which is too few. The minimum number of labels for any class cannot be less than n_folds=%d.c s= g | ]3 } t t | � j � � j d � j d � �� q S)rX rY )r �maxrT rX )�.0�c)r\ r8 r9 r: � <listcomp>4 s z,StratifiedKFold.__init__.<locals>.<listcomp>rD )rO r& r; rb r3 �asarray�shaperc r �min�allrT r6 �warnings�warn�WarningrX r rY rE r2 rd r � test_folds�y)r8 ru rT rX rY � n_samplesrf Z y_inversedZ label_countsZ min_labelsZ per_label_cvsrt Z test_fold_idxZper_label_splits�label�_Z test_splitZlabel_test_folds)rL )r\ r8 r: r; s6 " zStratifiedKFold.__init__c c s, x% t | j � D] } | j | k Vq Wd S)N)rK rT rt )r8 �ir9 r9 r: r= G s z StratifiedKFold._iter_test_masksc C s2 d | j j | j j | j | j | j | j f S)Nz9%s.%s(labels=%s, n_folds=%i, shuffle=%s, random_state=%s))rL rH rG ru rT rX rY )r8 r9 r9 r: rM K s zStratifiedKFold.__repr__c C s | j S)N)rT )r8 r9 r9 r: rN U s zStratifiedKFold.__len__)rG rH rI rJ r; r= rM rN r9 r9 )rL r: r& � s 90 c sL e Z d Z d Z � f d d � Z d d � Z d d � Z d d � Z � S) r! a� Leave-One-Label_Out cross-validation iterator .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.LeaveOneGroupOut` instead. Provides train/test indices to split data according to a third-party provided label. This label information can be used to encode arbitrary domain specific stratifications of the samples as integers. For instance the labels 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 <cross_validation>`. Parameters ---------- labels : array-like of int with shape (n_samples,) Arbitrary domain-specific stratification of the data to be used to draw the splits. Examples -------- >>> from sklearn import cross_validation >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) >>> y = np.array([1, 2, 1, 2]) >>> labels = np.array([1, 1, 2, 2]) >>> lol = cross_validation.LeaveOneLabelOut(labels) >>> len(lol) 2 >>> print(lol) sklearn.cross_validation.LeaveOneLabelOut(labels=[1 1 2 2]) >>> for train_index, test_index in lol: ... 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] See also -------- LabelKFold: K-fold iterator variant with non-overlapping labels. c s\ t t | � j t | � � t j | d d �| _ t j | � | _ t | j � | _ d S)N�copyT) rO r! r; rb r3 rQ re rc rf �n_unique_labels)r8 re )rL r9 r: r; � s zLeaveOneLabelOut.__init__c c s& x | j D] } | j | k Vq Wd S)N)rf re )r8 ry r9 r9 r: r= � s z!LeaveOneLabelOut._iter_test_masksc C s d | j j | j j | j f S)Nz%s.%s(labels=%s))rL rH rG re )r8 r9 r9 r: rM � s zLeaveOneLabelOut.__repr__c C s | j S)N)r{ )r8 r9 r9 r: rN � s zLeaveOneLabelOut.__len__)rG rH rI rJ r; r= rM rN r9 r9 )rL r: r! Y s 2 c sL e Z d Z d Z � f d d � Z d d � Z d d � Z d d � Z � S) r# a� Leave-P-Label_Out cross-validation iterator .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.LeavePGroupsOut` instead. Provides train/test indices to split data according to a third-party provided label. This label information can be used to encode arbitrary domain specific stratifications of the samples as integers. For instance the labels could be the year of collection of the samples and thus allow for cross-validation against time-based splits. The difference between LeavePLabelOut and LeaveOneLabelOut is that the former builds the test sets with all the samples assigned to ``p`` different values of the labels while the latter uses samples all assigned the same labels. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- labels : array-like of int with shape (n_samples,) Arbitrary domain-specific stratification of the data to be used to draw the splits. p : int Number of samples to leave out in the test split. Examples -------- >>> from sklearn import cross_validation >>> X = np.array([[1, 2], [3, 4], [5, 6]]) >>> y = np.array([1, 2, 1]) >>> labels = np.array([1, 2, 3]) >>> lpl = cross_validation.LeavePLabelOut(labels, p=2) >>> len(lpl) 3 >>> print(lpl) sklearn.cross_validation.LeavePLabelOut(labels=[1 2 3], p=2) >>> for train_index, test_index in lpl: ... 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 -------- LabelKFold: K-fold iterator variant with non-overlapping labels. c se t t | � j t | � � t j | d d �| _ t j | � | _ t | j � | _ | | _ d S)Nrz T) rO r# r; rb r3 rQ re rc rf r{ rP )r8 re rP )rL r9 r: r; � s zLeavePLabelOut.__init__c c s{ t t | j � | j � } xY | D]Q } | j � } t j | � } x( | j | D] } d | | j | k <qQ W| Vq" Wd S)NT) r rK r{ rP rB r3 rQ rf re )r8 rR �idxr? �lr9 r9 r: r= � s z LeavePLabelOut._iter_test_masksc C s& d | j j | j j | j | j f S)Nz%s.%s(labels=%s, p=%s))rL rH rG re rP )r8 r9 r9 r: rM � s zLeavePLabelOut.__repr__c C s4 t t | j � t | j | j � t | j � � S)N)r2 r r{ rP )r8 r9 r9 r: rN � s zLeavePLabelOut.__len__)rG rH rI rJ r; r= rM rN r9 r9 )rL r: r# � s ; c @ sL e Z d Z d Z d d d d d d � Z d d � Z e d d � � Z d S) �BaseShuffleSplitz6Base class for ShuffleSplit and StratifiedShuffleSplit� g�������?Nc C sO | | _ | | _ | | _ | | _ | | _ t | | | � \ | _ | _ d S)N)r7 �n_iter� test_size� train_sizerY �_validate_shuffle_split�n_train�n_test)r8 r7 r� r� r� rY r9 r9 r: r; s zBaseShuffleSplit.__init__c c s, x% | j � D] \ } } | | f Vq Wd S)N)� _iter_indices)r8 �train�testr9 r9 r: r@ s zBaseShuffleSplit.__iter__c C s d S)z Generate (train, test) indicesNr9 )r8 r9 r9 r: r� s z BaseShuffleSplit._iter_indices)rG rH rI rJ r; r@ r r� r9 r9 r9 r: r~ � s r~ c @ s: e Z d Z d Z d d � Z d d � Z d d � Z d S) r% a� Random permutation cross-validation iterator. .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.ShuffleSplit` instead. 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 <cross_validation>`. Parameters ---------- n : int Total number of elements in the dataset. n_iter : int (default 10) Number of re-shuffling & splitting iterations. test_size : float (default 0.1), int, or 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 automatically set to the complement of the 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 or RandomState Pseudo-random number generator state used for random sampling. Examples -------- >>> from sklearn import cross_validation >>> rs = cross_validation.ShuffleSplit(4, n_iter=3, ... test_size=.25, random_state=0) >>> len(rs) 3 >>> print(rs) ... # doctest: +ELLIPSIS ShuffleSplit(4, n_iter=3, test_size=0.25, ...) >>> for train_index, test_index in rs: ... print("TRAIN:", train_index, "TEST:", test_index) ... TRAIN: [3 1 0] TEST: [2] TRAIN: [2 1 3] TEST: [0] TRAIN: [0 2 1] TEST: [3] >>> rs = cross_validation.ShuffleSplit(4, n_iter=3, ... train_size=0.5, test_size=.25, random_state=0) >>> for train_index, test_index in rs: ... print("TRAIN:", train_index, "TEST:", test_index) ... TRAIN: [3 1] TEST: [2] TRAIN: [2 1] TEST: [0] TRAIN: [0 2] TEST: [3] c c sz t | j � } xd t | j � D]S } | j | j � } | d | j � } | | j | j | j � } | | f Vq Wd S)N)r rY rK r� � permutationr7 r� r� )r8 r\ ry r� Zind_testZ ind_trainr9 r9 r: r� X s zShuffleSplit._iter_indicesc C s/ d | j j | j | j t | j � | j f S)Nz0%s(%d, n_iter=%d, test_size=%s, random_state=%s))rL rG r7 r� �strr� rY )r8 r9 r9 r: rM a s zShuffleSplit.__repr__c C s | j S)N)r� )r8 r9 r9 r: rN k s zShuffleSplit.__len__N)rG rH rI rJ r� rM rN r9 r9 r9 r: r% s @ c C s� | d k r$ | d k r$ t d � � | d k r� t j | � j j d k rj | d k r� t d | � � nP t j | � j j d k r� | | k r� t d | | f � � n t d | � � | d k r�t j | � j j d k rB| d k r t d | � � q�t j | � j j d k r�| | d k r�t d | | � � nP t j | � j j d k r�| | k r�t d | | f � � n t d | � � t j | � j j d k r�t | | � } n' t j | � j j d k r�t | � } | d k r | | } n: t j | � j j d k r.t | | � } n t | � } | d k rP| | } | | | k rzt d | | | f � � t | � t | � f S) Nz-test_size and train_size can not both be Noner0 g �?z8test_size=%f should be smaller than 1.0 or be an integerry z<test_size=%d should be smaller than the number of samples %dz Invalid value for test_size: %rz9train_size=%f should be smaller than 1.0 or be an integerziThe sum of test_size and train_size = %f, should be smaller than 1.0. Reduce test_size and/or train_size.z=train_size=%d should be smaller than the number of samples %dz Invalid value for train_size: %rz~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.) r6 r3 rm rD �kindr �floatr r2 )r7 r� r� r� r� r9 r9 r: r� o sX r� c C s | | | j � } t j | � } t | | j � � } | d k r� | | } t j t j | � � d d d � } x~ | D]v } t j | | k � \ } t t | � | � } t | d | d d d | �} | | d 7<| | 8} | d k r{ Pq{ W| j t j � S) a� 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 r Nr �size�replaceFrY ra ) �sumr3 r r2 �sortrc rh ro rb r Zastype) Z class_countsZn_drawsr\ Z continuousZflooredZ need_to_addZ remainder�values�valueZindsZadd_nowr9 r9 r: �_approximate_mode� s % r� c sX e Z d Z d Z d d d d � f d d � Z d d � Z d d � Z d d � Z � S) r' a? Stratified ShuffleSplit cross validation iterator .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.StratifiedShuffleSplit` instead. 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 <cross_validation>`. Parameters ---------- y : array, [n_samples] Labels of samples. n_iter : int (default 10) Number of re-shuffling & splitting iterations. test_size : float (default 0.1), int, or 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 automatically set to the complement of the 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 or RandomState Pseudo-random number generator state used for random sampling. Examples -------- >>> from sklearn.cross_validation import StratifiedShuffleSplit >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> sss = StratifiedShuffleSplit(y, 3, test_size=0.5, random_state=0) >>> len(sss) 3 >>> print(sss) # doctest: +ELLIPSIS StratifiedShuffleSplit(labels=[0 0 1 1], n_iter=3, ...) >>> for train_index, test_index in sss: ... 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: [3 0] TRAIN: [0 2] TEST: [1 3] TRAIN: [0 2] TEST: [3 1] r g�������?Nc s� t t | � j t | � | | | | � t j | � | _ t j | d d �\ | _ | _ | j j d } t j t | j � � d k r� t d � � | j | k r� t d | j | f � � | j | k r� t d | j | f � � d S)Nr` Tr � z�The least populated class in y has only 1 member, which is too few. The minimum number of labels 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 = %d)rO r' r; rb r3 rQ ru rc �classes� y_indicesrn ro r r6 r� r� )r8 ru r� r� r� rY Zn_cls)rL r9 r: r; s ! z StratifiedShuffleSplit.__init__c c s: t | j � } t | j � } xt | j � D]} t | | j | � } | | } t | | j | � } g } g } x� t | j � D]� \ } } | j | | � } t j | | j k � d | } | j | d | | � � | j | | | | | | | � � q� W| j | � } | j | � } | | f Vq. Wd S)Nr )r rY r r� rK r� r� r� r� rd r� r� r3 rh �extend) r8 r\ Z cls_countr7 Zn_iZclass_counts_remainingZt_ir� r� ry rx r� Zperm_indices_class_ir9 r9 r: r� 9 s" +z$StratifiedShuffleSplit._iter_indicesc C s/ d | j j | j | j t | j � | j f S)Nz7%s(labels=%s, n_iter=%d, test_size=%s, random_state=%s))rL rG ru r� r� r� rY )r8 r9 r9 r: rM S s z StratifiedShuffleSplit.__repr__c C s | j S)N)r� )r8 r9 r9 r: rN ] s z StratifiedShuffleSplit.__len__)rG rH rI rJ r; r� rM rN r9 r9 )rL r: r' � s ; c sL e Z d Z d Z � f d d � Z d d � Z d d � Z d d � Z � S) r( a� Predefined split cross validation iterator .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.PredefinedSplit` instead. Splits the data into training/test set folds according to a predefined scheme. Each sample can be assigned to at most one test set fold, as specified by the user through the ``test_fold`` parameter. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- test_fold : "array-like, shape (n_samples,) test_fold[i] gives the test set fold of sample i. A value of -1 indicates that the corresponding sample is not part of any test set folds, but will instead always be put into the training fold. Examples -------- >>> from sklearn.cross_validation import PredefinedSplit >>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> y = np.array([0, 0, 1, 1]) >>> ps = PredefinedSplit(test_fold=[0, 1, -1, 1]) >>> len(ps) 2 >>> print(ps) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS sklearn.cross_validation.PredefinedSplit(test_fold=[ 0 1 -1 1]) >>> for train_index, test_index in ps: ... 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] c s{ t t | � j t | � � t j | d t j �| _ t | j � | _ t j | j � | _ | j | j d k | _ d S)NrD r ra ) rO r( r; rb r3 rQ r2 � test_foldr rc � unique_folds)r8 r� )rL r9 r: r; � s zPredefinedSplit.__init__c c s3 x, | j D]! } t j | j | k � d Vq Wd S)Nr )r� r3 rh r� )r8 r0 r9 r9 r: rA � s z"PredefinedSplit._iter_test_indicesc C s d | j j | j j | j f S)Nz%s.%s(test_fold=%s))rL rH rG r� )r8 r9 r9 r: rM � s zPredefinedSplit.__repr__c C s t | j � S)N)rb r� )r8 r9 r9 r: rN � s zPredefinedSplit.__len__)rG rH rI rJ r; rA rM rN r9 r9 )rL r: r( a s $ c s^ e Z d Z d Z d d d d � f d d � Z d d � Z d d � Z � f d d � Z � S) r) aQ Shuffle-Labels-Out cross-validation iterator .. deprecated:: 0.18 This module will be removed in 0.20. Use :class:`sklearn.model_selection.GroupShuffleSplit` instead. Provides randomized train/test indices to split data according to a third-party provided label. This label information can be used to encode arbitrary domain specific stratifications of the samples as integers. For instance the labels could be the year of collection of the samples and thus allow for cross-validation against time-based splits. The difference between LeavePLabelOut and LabelShuffleSplit is that the former generates splits using all subsets of size ``p`` unique labels, whereas LabelShuffleSplit generates a user-determined number of random test splits, each with a user-determined fraction of unique labels. For example, a less computationally intensive alternative to ``LeavePLabelOut(labels, p=10)`` would be ``LabelShuffleSplit(labels, test_size=10, n_iter=100)``. Note: The parameters ``test_size`` and ``train_size`` refer to labels, and not to samples, as in ShuffleSplit. .. versionadded:: 0.17 Parameters ---------- labels : array, [n_samples] Labels of samples n_iter : int (default 5) Number of re-shuffling and splitting iterations. test_size : float (default 0.2), int, or None If float, should be between 0.0 and 1.0 and represent the proportion of the labels to include in the test split. If int, represents the absolute number of test labels. If None, the value is automatically set to the complement of the 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 labels to include in the train split. If int, represents the absolute number of train labels. If None, the value is automatically set to the complement of the test size. random_state : int or RandomState Pseudo-random number generator state used for random sampling. � g�������?Nc sn t j | d d �\ } } t t | � j t | � d | d | d | d | �| | _ | | _ | | _ d S)Nr` Tr� r� r� rY ) r3 rc rO r) r; rb re r� � label_indices)r8 re r� r� r� rY r� r� )rL r9 r: r; � s zLabelShuffleSplit.__init__c C s/ d | j j | j | j t | j � | j f S)Nz7%s(labels=%s, n_iter=%d, test_size=%s, random_state=%s))rL rG re r� r� r� rY )r8 r9 r9 r: rM � s zLabelShuffleSplit.__repr__c C s | j S)N)r� )r8 r9 r9 r: rN � s zLabelShuffleSplit.__len__c # sq xj t t | � j � D]S \ } } t j t j | j | � � } t j t j | j | � � } | | f Vq Wd S)N)rO r) r� r3 Z flatnonzeroZin1dr� )r8 Z label_trainZ label_testr� r� )rL r9 r: r� � s z LabelShuffleSplit._iter_indices)rG rH rI rJ r; rM rN r� r9 r9 )rL r: r) � s 3 c C sQ t | � s% t | � t | � k r) | St j | � rD | j � } t | | � S)z5Private helper function for parameter value indexing.)r r �sp�issparseZtocsrr )�X�vrg r9 r9 r: �_index_param_value� s % r� z2*n_jobsc sF t � � � \ � � t | � � d t � � �} t d | d � d | � } | � � � � � f d d � | D� � } d d � | D� } t j d d � | D� � } t | t � � � s� t d � � t j t | � d t �} t j t | � � | | <t j | d � r/t j | d | d j �} n t j | � } | | S)a� Generate cross-validated estimates for each input data point .. deprecated:: 0.18 This module will be removed in 0.20. Use :func:`sklearn.model_selection.cross_val_predict` instead. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- estimator : estimator object implementing 'fit' and 'predict' The object to use to fit the data. X : array-like The data to fit. Can be, for example a list, or an array at least 2d. y : array-like, optional, default: None The target variable to try to predict in the case of supervised learning. 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. - An object to be used as a cross-validation generator. - An iterable yielding train/test splits. For integer/None inputs, if the estimator is a classifier and ``y`` is either binary or multiclass, :class:`StratifiedKFold` is used. In all other cases, :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. n_jobs : integer, optional The number of CPUs to use to do the computation. -1 means 'all CPUs'. verbose : integer, optional The verbosity level. fit_params : dict, optional Parameters to pass to the fit method of the estimator. pre_dispatch : int, or string, optional Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process. This parameter can be: - None, in which case all the jobs are immediately created and spawned. Use this for lightweight and fast-running jobs, to avoid delays due to on-demand spawning of the jobs - An int, giving the exact number of total jobs that are spawned - A string, giving an expression as a function of n_jobs, as in '2*n_jobs' Returns ------- preds : ndarray This is the result of calling 'predict' Examples -------- >>> from sklearn import datasets, linear_model >>> from sklearn.cross_validation import cross_val_predict >>> diabetes = datasets.load_diabetes() >>> X = diabetes.data[:150] >>> y = diabetes.target[:150] >>> lasso = linear_model.Lasso() >>> y_pred = cross_val_predict(lasso, X, y) � classifier�n_jobs�verbose� pre_dispatchc 3 s? | ]5 \ } } t t � t � � � � | | � � � Vq d S)N)r �_fit_and_predictr )rj r� r� )r� � estimator� fit_paramsr� ru r9 r: � <genexpr>[ s z$cross_val_predict.<locals>.<genexpr>c S s g | ] \ } } | � q Sr9 r9 )rj rP rx r9 r9 r: rl ` s z%cross_val_predict.<locals>.<listcomp>c S s g | ] \ } } | � q Sr9 r9 )rj rx �locr9 r9 r: rl a s z+cross_val_predict only works for partitionsrD r rU )r r* r r r3 Z concatenate�_check_is_partitionr r6 �emptyrb r2 r< r� r� ZvstackrU ) r� r� ru �cvr� r� r� r� �parallelZ preds_blocks�preds�locsZinv_locsr9 )r� r� r� r� ru r: r, s P c s� | d k r | n i } t � � f d d � | j � D� � } t | � | � � \ } } t | � | | � � \ } } | d k r� | j | | � n | j | | | � | j | � } | | f S)a� Fit estimator and predict values for a given dataset split. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- estimator : estimator object implementing 'fit' and 'predict' The object to use to fit the data. X : array-like of shape at least 2D The data to fit. y : array-like, optional, default: None The target variable to try to predict in the case of supervised learning. train : array-like, shape (n_train_samples,) Indices of training samples. test : array-like, shape (n_test_samples,) Indices of test samples. verbose : integer The verbosity level. fit_params : dict or None Parameters that will be passed to ``estimator.fit``. Returns ------- preds : sequence Result of calling 'estimator.predict' test : array-like This is the value of the test parameter Nc s. g | ]$ \ } } | t � | � � f � q Sr9 )r� )rj �kr� )r� r� r9 r: rl � s z$_fit_and_predict.<locals>.<listcomp>)�dict�items� _safe_split�fitZpredict) r� r� ru r� r� r� r� �X_train�y_train�X_testrx r� r9 )r� r� r: r� o s & r� c C sI t | � | k r d St j | t � } d | | <t j | � sE d Sd S)a Check whether locs is a reordering of the array np.arange(n) Parameters ---------- locs : ndarray integer array to test n : int number of expected elements Returns ------- is_partition : bool True iff sorted(locs) is range(n) FT)rb r3 rE rF rp )r� r7 Zhitr9 r9 r: r� � s r� c s� t � � � \ � � t | � � d t � � �} t � d | �� t d | d � d | � } | � � � � � � f d d � | D� � } t j | � d d � d f S) a� Evaluate a score by cross-validation .. deprecated:: 0.18 This module will be removed in 0.20. Use :func:`sklearn.model_selection.cross_val_score` instead. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- estimator : estimator object implementing 'fit' The object to use to fit the data. X : array-like The data to fit. Can be, for example a list, or an array at least 2d. y : array-like, optional, default: None The target variable to try to predict in the case of supervised learning. scoring : string, callable or None, optional, default: None A string (see model evaluation documentation) or a scorer callable object / function with signature ``scorer(estimator, X, y)``. 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. - An object to be used as a cross-validation generator. - An iterable yielding train/test splits. For integer/None inputs, if the estimator is a classifier and ``y`` is either binary or multiclass, :class:`StratifiedKFold` is used. In all other cases, :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. n_jobs : integer, optional The number of CPUs to use to do the computation. -1 means 'all CPUs'. verbose : integer, optional The verbosity level. fit_params : dict, optional Parameters to pass to the fit method of the estimator. pre_dispatch : int, or string, optional Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process. This parameter can be: - None, in which case all the jobs are immediately created and spawned. Use this for lightweight and fast-running jobs, to avoid delays due to on-demand spawning of the jobs - An int, giving the exact number of total jobs that are spawned - A string, giving an expression as a function of n_jobs, as in '2*n_jobs' Returns ------- scores : array of float, shape=(len(list(cv)),) Array of scores of the estimator for each run of the cross validation. Examples -------- >>> from sklearn import datasets, linear_model >>> from sklearn.cross_validation import cross_val_score >>> diabetes = datasets.load_diabetes() >>> X = diabetes.data[:150] >>> y = diabetes.target[:150] >>> lasso = linear_model.Lasso() >>> print(cross_val_score(lasso, X, y)) # doctest: +ELLIPSIS [ 0.33150734 0.08022311 0.03531764] See Also --------- :func:`sklearn.metrics.make_scorer`: Make a scorer from a performance metric or loss function. r� �scoringr� r� r� c 3 sE | ]; \ } } t t � t � � � � � | | � d � � Vq d S)N)r �_fit_and_scorer )rj r� r� )r� r� r� �scorerr� ru r9 r: r� s z"cross_val_score.<locals>.<genexpr>Nr )r r* r r r r3 rQ ) r� r� ru r� r� r� r� r� r� r� Zscoresr9 )r� r� r� r� r� ru r: r+ � s \ ! F�raisec s� | d k ri | d k r! d } n& d d j d d � | j � D� � } t d | d t | � d f � | d k r{ | n i } t � � f d d � | j � D� � } | d k r� | j | � t j � } t | � | � � \ } } t | � | | � � \ } } y6 | d k r)| j | | � n | j | | | � Wn� t k r�} zd | d k rd� nM t | t j � r�| } | r�| } t j d | | f t � n t d � � WYd d } ~ Xn1 Xt | | | | � } | r�t | | | | � } t j � | } | d k r | d | 7} | d k red | t j | � f } t d d t | � d | f � | rt| g n g } | j | t | � | g � | r�| j | � | S)aY Fit estimator and compute scores for a given dataset split. Parameters ---------- estimator : estimator object implementing 'fit' The object to use to fit the data. X : array-like of shape at least 2D The data to fit. y : array-like, optional, default: None The target variable to try to predict in the case of supervised learning. scorer : callable A scorer callable object / function with signature ``scorer(estimator, X, y)``. train : array-like, shape (n_train_samples,) Indices of training samples. test : array-like, shape (n_test_samples,) Indices of test samples. verbose : integer The verbosity level. error_score : 'raise' (default) or numeric Value to assign to the score if an error occurs in estimator fitting. If set to 'raise', the error is raised. If a numeric value is given, FitFailedWarning is raised. This parameter does not affect the refit step, which will always raise the error. parameters : dict or None Parameters to be set on the estimator. fit_params : dict or None Parameters that will be passed to ``estimator.fit``. return_train_score : boolean, optional, default: False Compute and return score on training set. return_parameters : boolean, optional, default: False Return parameters that has been used for the estimator. Returns ------- train_score : float, optional Score on training set, returned only if `return_train_score` is `True`. test_score : float Score on test set. n_test_samples : int Number of test samples. scoring_time : float Time spent for fitting and scoring in seconds. parameters : dict or None, optional The parameters that have been evaluated. r N� z%sz, c s s% | ] \ } } d | | f Vq d S)z%s=%sNr9 )rj r� r� r9 r9 r: r� l s z!_fit_and_score.<locals>.<genexpr>z [CV] %s %s�@ �.c s. g | ]$ \ } } | t � | � � f � q Sr9 )r� )rj r� r� )r� r� r9 r: rl r s z"_fit_and_score.<locals>.<listcomp>r� zrClassifier fit failed. The score on this train-test partition for these parameters will be set to %f. Details: %rz�error_score must be the string 'raise' or a numeric value. (Hint: if using 'raise', please make sure that it has been spelled correctly.)r� z , score=%fz%s -%s)�joinr� �printrb r� Z set_params�timer� r� � ExceptionrV �numbers�Numberrq rr r r6 �_scorer Zshort_format_timer� r �append)r� r� ru r� r� r� r� Z parametersr� Zreturn_train_scoreZreturn_parametersZ error_score�msgZ start_timer� r� r� �y_test�eZ test_scoreZ train_scoreZ scoring_timeZend_msgZretr9 )r� r� r: r� ' sT A " " r� c s9 t | d � r= t | j � r= t | j t � r= t d � � t � d � s� t | d d � rj t d � � � f d d � | D� } n� t | d d � r� � j d � j d k r� t d � � | d k r� � t j | | � } q � t j | | � } n t � | � } | d k r)t | | � } n d } | | f S) z5Create subset of dataset and properly handle kernels.�kernelzJCannot use a custom kernel function. Precompute the kernel matrix instead.rn Z _pairwiseFzXPrecomputed kernels or affinity matrices have to be passed as arrays or sparse matrices.c s g | ] } � | � q Sr9 r9 )rj r| )r� r9 r: rl � s z _safe_split.<locals>.<listcomp>r r z"X should be a square kernel matrixN) �hasattr�callabler� rV �GPKernelr6 �getattrrn r3 Zix_r )r� r� ru rg Z train_indicesZX_subsetZy_subsetr9 )r� r: r� � s$ r� c C s� | d k r | | | � } n | | | | � } t | d � rd y | j � } Wn t k rc Yn Xt | t j � s� t d t | � t | � f � � | S)z6Compute the score of an estimator on a given test set.N�itemz2scoring must return a number, got %s (%s) instead.)r� r� r6 rV r� r� r� �type)r� r� r� r� �scorer9 r9 r: r� � s r� c C sc g } xM | D]E \ } } | j | | | | � | j | | | | | | � � q Wt j | � S)z-Auxiliary function for permutation_test_score)r� r� r3 Zmean)r� r� ru r� r� Z avg_scorer� r� r9 r9 r: �_permutation_test_score� s %r� c C s~ | d k r$ | j t | � � } nR t j t | � � } x: t j | � D]) } | | k } | j | | � | | <qI W| | S)zAReturn a shuffled copy of y eventually shuffle among same labels.N)r� rb r3 r< rc )ru re rY r> rw Z this_maskr9 r9 r: �_shuffle� s r� c C s� t j | � } | d k r! d } t | t j � r� | ru t | � d k r] t | | � } q� t t | � | � } n1 | s� t | � } n | j d } t | | � } | S)a� Input checker utility for building a CV in a user friendly way. .. deprecated:: 0.18 This module will be removed in 0.20. Use :func:`sklearn.model_selection.check_cv` instead. 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. - An object to be used as a cross-validation generator. - An iterable yielding train/test splits. For integer/None inputs, if classifier is True and ``y`` is binary or multiclass, :class:`StratifiedKFold` is used. In all other cases, :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. X : array-like The data the cross-val object will be applied on. y : array-like The target variable for a supervised learning problem. classifier : boolean optional Whether the task is a classification task, in which case stratified KFold will be used. Returns ------- checked_cv: a cross-validation generator instance. The return value is guaranteed to be a cv generator instance, whatever the input type. NrZ �binary� multiclassr )r� r� ) r� r� rV r� ZIntegralr r& r r rb rn )r� r� ru r� Z is_sparserv r9 r9 r: r* � s ) �d c s� t � � � \ � � t � � � d t � � �� t � d | �� t � � � t t � � � � � � � } t d | d | � � � � � � � � f d d � t | � D� � } t j | � } t j | | k � d | d } | | | f S) a. Evaluate the significance of a cross-validated score with permutations .. deprecated:: 0.18 This module will be removed in 0.20. Use :func:`sklearn.model_selection.permutation_test_score` instead. Read more in the :ref:`User Guide <cross_validation>`. Parameters ---------- estimator : estimator object implementing 'fit' The object to use to fit the data. X : array-like of shape at least 2D The data to fit. y : array-like The target variable to try to predict in the case of supervised learning. scoring : string, callable or None, optional, default: None A string (see model evaluation documentation) or a scorer callable object / function with signature ``scorer(estimator, X, y)``. 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. - An object to be used as a cross-validation generator. - An iterable yielding train/test splits. For integer/None inputs, if the estimator is a classifier and ``y`` is either binary or multiclass, :class:`StratifiedKFold` is used. In all other cases, :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. n_permutations : integer, optional Number of times to permute ``y``. n_jobs : integer, optional The number of CPUs to use to do the computation. -1 means 'all CPUs'. labels : array-like of shape [n_samples] (optional) Labels constrain the permutation among groups of samples with a same label. random_state : RandomState or an int seed (0 by default) A random number generator instance to define the state of the random permutations generator. verbose : integer, optional The verbosity level. Returns ------- score : float The true score without permuting targets. permutation_scores : array, shape (n_permutations,) The scores obtained for each permutations. pvalue : float The returned value equals p-value if `scoring` returns bigger numbers for better scores (e.g., accuracy_score). If `scoring` is rather a loss function (i.e. when lower is better such as with `mean_squared_error`) then this is actually the complement of the p-value: 1 - p-value. Notes ----- This function implements Test 1 in: Ojala and Garriga. Permutation Tests for Studying Classifier Performance. The Journal of Machine Learning Research (2010) vol. 11 r� r� r� r� c 3 s? | ]5 } t t � t � � � t � � � � � � � Vq d S)N)r r� r r� )rj rx )r� r� r� re rY r� ru r9 r: r� � s z)permutation_test_score.<locals>.<genexpr>g �?r ) r r* r r r r� r r rK r3 rQ r� ) r� r� ru r� Zn_permutationsr� re rY r� r� r� Zpermutation_scoresZpvaluer9 )r� r� r� re rY r� ru r: r- + s V !!c sN t | � } | d k r$ t d � � | j d d � } | j d d � } | j d d � } | j d d � } | r� t d t | � � � | d k r� | d k r� d } t | � } | d k r� t | d | d | d | �} n. t | d � } t | d | d | d | �} t t | � � \ � � t t j � � f d d � | D� � � S) an Split arrays or matrices into random train and test subsets .. deprecated:: 0.18 This module will be removed in 0.20. Use :func:`sklearn.model_selection.train_test_split` instead. Quick utility that wraps input validation and ``next(iter(ShuffleSplit(n_samples)))`` 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 <cross_validation>`. 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 (default is 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 automatically set to the complement of the train size. If train size is also None, test size is set to 0.25. 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 or RandomState Pseudo-random number generator state used for random sampling. stratify : array-like or None (default is None) If not None, data is split in a stratified fashion, using this as the labels array. .. versionadded:: 0.17 *stratify* splitting 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.cross_validation 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] r z$At least one array required as inputr� Nr� rY �stratifyz Invalid parameters passed: %sg �?c 3 s- | ]# } t | � � t | � � f Vq d S)N)r )rj �a)r� r� r9 r: r� s z#train_test_split.<locals>.<genexpr>)rb r6 �poprW r� r r' r r% �next�iter�listr � from_iterable) ZarraysZoptionsZn_arraysr� r� rY r� r� rv r9 )r� r� r: r. � s. S )WrJ Z __future__r r rq � itertoolsr r �mathr r r r� r� �abcr r Znumpyr3 Z scipy.sparseZsparser� �baser r Zutilsr r r Zutils.validationr r r Zutils.multiclassr Z utils.randomr Zexternals.joblibr r r Z externals.sixr Zexternals.six.movesr Zmetrics.scorerr Z utils.fixesr Zgaussian_process.kernelsr r� � exceptionsr rr �DeprecationWarning�__all__r/ r" r$ rS r r r& r! r# r~ r% r� r� r' r( r) r� r, r� r� r+ r� r� r� r� r� r* r- Z__test__r. r9 r9 r9 r: �<module> s� ,BG _j~J\ Y ? 5~;^ j 5 k~! ; f q
Edit
Rename
Chmod
Delete
FILE
FOLDER
Name
Size
Permission
Action
__init__.cpython-35.opt-1.pyc
2267 bytes
0644
__init__.cpython-35.pyc
2267 bytes
0644
base.cpython-35.opt-1.pyc
17198 bytes
0644
base.cpython-35.pyc
17198 bytes
0644
calibration.cpython-35.opt-1.pyc
18382 bytes
0644
calibration.cpython-35.pyc
18382 bytes
0644
cross_validation.cpython-35.opt-1.pyc
68580 bytes
0644
cross_validation.cpython-35.pyc
68580 bytes
0644
discriminant_analysis.cpython-35.opt-1.pyc
26569 bytes
0644
discriminant_analysis.cpython-35.pyc
26569 bytes
0644
dummy.cpython-35.opt-1.pyc
15443 bytes
0644
dummy.cpython-35.pyc
15443 bytes
0644
exceptions.cpython-35.opt-1.pyc
5892 bytes
0644
exceptions.cpython-35.pyc
5892 bytes
0644
grid_search.cpython-35.opt-1.pyc
37096 bytes
0644
grid_search.cpython-35.pyc
37096 bytes
0644
isotonic.cpython-35.opt-1.pyc
12665 bytes
0644
isotonic.cpython-35.pyc
12665 bytes
0644
kernel_approximation.cpython-35.opt-1.pyc
16865 bytes
0644
kernel_approximation.cpython-35.pyc
16865 bytes
0644
kernel_ridge.cpython-35.opt-1.pyc
6644 bytes
0644
kernel_ridge.cpython-35.pyc
6644 bytes
0644
lda.cpython-35.opt-1.pyc
802 bytes
0644
lda.cpython-35.pyc
802 bytes
0644
learning_curve.cpython-35.opt-1.pyc
13957 bytes
0644
learning_curve.cpython-35.pyc
13957 bytes
0644
multiclass.cpython-35.opt-1.pyc
28997 bytes
0644
multiclass.cpython-35.pyc
28997 bytes
0644
multioutput.cpython-35.opt-1.pyc
9728 bytes
0644
multioutput.cpython-35.pyc
9728 bytes
0644
naive_bayes.cpython-35.opt-1.pyc
26877 bytes
0644
naive_bayes.cpython-35.pyc
26877 bytes
0644
pipeline.cpython-35.opt-1.pyc
28874 bytes
0644
pipeline.cpython-35.pyc
28874 bytes
0644
qda.cpython-35.opt-1.pyc
815 bytes
0644
qda.cpython-35.pyc
815 bytes
0644
random_projection.cpython-35.opt-1.pyc
20389 bytes
0644
random_projection.cpython-35.pyc
20389 bytes
0644
setup.cpython-35.opt-1.pyc
2299 bytes
0644
setup.cpython-35.pyc
2299 bytes
0644
N4ST4R_ID | Naxtarrr
