U ei@sdZddlZddlmZmZddlmZddlm Z ddlm Z ddl m Z m Z dd lmZdd lmZdd lmZmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl m"Z"ddZ#ddZ$Gddde!eeZ%Gddde%Z&dS)z1Recursive feature elimination for feature rankingN)IntegralReal)effective_n_jobs) available_if) _safe_split) HasMethodsInterval) _safe_tags)check_is_fitted)delayedParallel) BaseEstimator)MetaEstimatorMixin)clone) is_classifier)check_cv_score) check_scoring) SelectorMixin)_get_feature_importancesc sBt||||\}}t|||||\|||fddjS)z5 Return the score for a fit across one fold. cst|dd|fSNr) estimatorfeaturesZX_testscorerZy_test_/var/www/html/assets/scripts/venv/lib/python3.8/site-packages/sklearn/feature_selection/_rfe.py(s z!_rfe_single_fit..)r_fitscores_) rferXytraintestrZX_trainZy_trainrrr_rfe_single_fitsr(cs fddS)zCheck if we can delegate a method to the underlying estimator. First, we check the first fitted estimator if available, otherwise we check the unfitted estimator. cs"t|drt|jSt|jS)N estimator_)hasattrr)rselfattrrrr 4sz _estimator_has..rr-rr-r_estimator_has.sr/c @s$eZdZUdZedggdeeddddeeddddgeeddddeeddddgd gee gd Z e e d <dddd d ddZ eddZeddZddZd+ddZeedddZeedddZddZeed d!d"Zeed#d$d%Zeed&d'd(Zd)d*ZdS),RFEarFeature ranking with recursive feature elimination. Given an external estimator that assigns weights to features (e.g., the coefficients of a linear model), the goal of recursive feature elimination (RFE) is to select features by recursively considering smaller and smaller sets of features. First, the estimator is trained on the initial set of features and the importance of each feature is obtained either through any specific attribute or callable. Then, the least important features are pruned from current set of features. That procedure is recursively repeated on the pruned set until the desired number of features to select is eventually reached. Read more in the :ref:`User Guide `. Parameters ---------- estimator : ``Estimator`` instance A supervised learning estimator with a ``fit`` method that provides information about feature importance (e.g. `coef_`, `feature_importances_`). n_features_to_select : int or float, default=None The number of features to select. If `None`, half of the features are selected. If integer, the parameter is the absolute number of features to select. If float between 0 and 1, it is the fraction of features to select. .. versionchanged:: 0.24 Added float values for fractions. step : int or float, default=1 If greater than or equal to 1, then ``step`` corresponds to the (integer) number of features to remove at each iteration. If within (0.0, 1.0), then ``step`` corresponds to the percentage (rounded down) of features to remove at each iteration. verbose : int, default=0 Controls verbosity of output. importance_getter : str or callable, default='auto' If 'auto', uses the feature importance either through a `coef_` or `feature_importances_` attributes of estimator. Also accepts a string that specifies an attribute name/path for extracting feature importance (implemented with `attrgetter`). For example, give `regressor_.coef_` in case of :class:`~sklearn.compose.TransformedTargetRegressor` or `named_steps.clf.feature_importances_` in case of class:`~sklearn.pipeline.Pipeline` with its last step named `clf`. If `callable`, overrides the default feature importance getter. The callable is passed with the fitted estimator and it should return importance for each feature. .. versionadded:: 0.24 Attributes ---------- classes_ : ndarray of shape (n_classes,) The classes labels. Only available when `estimator` is a classifier. estimator_ : ``Estimator`` instance The fitted estimator used to select features. n_features_ : int The number of selected features. n_features_in_ : int Number of features seen during :term:`fit`. Only defined if the underlying estimator exposes such an attribute when fit. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 ranking_ : ndarray of shape (n_features,) The feature ranking, such that ``ranking_[i]`` corresponds to the ranking position of the i-th feature. Selected (i.e., estimated best) features are assigned rank 1. support_ : ndarray of shape (n_features,) The mask of selected features. See Also -------- RFECV : Recursive feature elimination with built-in cross-validated selection of the best number of features. SelectFromModel : Feature selection based on thresholds of importance weights. SequentialFeatureSelector : Sequential cross-validation based feature selection. Does not rely on importance weights. Notes ----- Allows NaN/Inf in the input if the underlying estimator does as well. References ---------- .. [1] Guyon, I., Weston, J., Barnhill, S., & Vapnik, V., "Gene selection for cancer classification using support vector machines", Mach. Learn., 46(1-3), 389--422, 2002. Examples -------- The following example shows how to retrieve the 5 most informative features in the Friedman #1 dataset. >>> from sklearn.datasets import make_friedman1 >>> from sklearn.feature_selection import RFE >>> from sklearn.svm import SVR >>> X, y = make_friedman1(n_samples=50, n_features=10, random_state=0) >>> estimator = SVR(kernel="linear") >>> selector = RFE(estimator, n_features_to_select=5, step=1) >>> selector = selector.fit(X, y) >>> selector.support_ array([ True, True, True, True, True, False, False, False, False, False]) >>> selector.ranking_ array([1, 1, 1, 1, 1, 6, 4, 3, 2, 5]) fitNrrrightclosedneitherverbose)rn_features_to_selectstepr6importance_getter_parameter_constraintsauto)r7r8r6r9cCs"||_||_||_||_||_dSrrr7r8r9r6)r,rr7r8r6r9rrr__init__s z RFE.__init__cCs|jjSr)r_estimator_typer+rrrr>szRFE._estimator_typecCs|jjS)zClasses labels available when `estimator` is a classifier. Returns ------- ndarray of shape (n_classes,) )r)classes_r+rrrr?sz RFE.classes_cKs||j||f|S)aFit the RFE model and then the underlying estimator on the selected features. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The training input samples. y : array-like of shape (n_samples,) The target values. **fit_params : dict Additional parameters passed to the `fit` method of the underlying estimator. Returns ------- self : object Fitted estimator. )_validate_paramsr!r,r$r% fit_paramsrrrr1szRFE.fitc Ks|}|j||dd|dd dd\}}|jd}|jdkrJ|d}n"t|jtr^|j}nt||j}d|jkrdkrnntt d|j|}n t|j}t j |t d } t j |td } |rg|_ t | |krt || } t|j} |jd krtd t | | j|dd| f|f|t| |jd d } t | }t |}t|t | |}|r~|j || | d| | |d|<| t | d7<qt || } t|j|_|jj|dd| f|f||r|j ||j| | |_| |_| |_|S)NZcscr allow_nanTZ accept_sparseZensure_min_featuresZforce_all_finiteZ multi_outputr?)Zdtyperz#Fitting estimator with %d features.Zsquare)Ztransform_funcF) _get_tags_validate_datagetshaper7 isinstancerintr8maxnpZonesboolr"sumZarangerrr6printr1rr9ZargsortZravelminappendZ logical_notr) n_features_support_ranking_)r,r$r%Z step_scorerBtags n_featuresr7r8rUrVrrZ importancesZranks thresholdrrrr!sb            zRFE._fitpredictcCst||j||S)a5Reduce X to the selected features and predict using the estimator. Parameters ---------- X : array of shape [n_samples, n_features] The input samples. Returns ------- y : array of shape [n_samples] The predicted target values. )r r)rZ transformr,r$rrrrZQsz RFE.predictscorecKs t||jj|||f|S)aqReduce X to the selected features and return the score of the estimator. Parameters ---------- X : array of shape [n_samples, n_features] The input samples. y : array of shape [n_samples] The target values. **fit_params : dict Parameters to pass to the `score` method of the underlying estimator. .. versionadded:: 1.0 Returns ------- score : float Score of the underlying base estimator computed with the selected features returned by `rfe.transform(X)` and `y`. )r r)r]r[rArrrr]bsz RFE.scorecCst||jSr)r rUr+rrr_get_support_mask}szRFE._get_support_maskdecision_functioncCst||j||S)aCompute the decision function of ``X``. Parameters ---------- X : {array-like or sparse matrix} of shape (n_samples, n_features) The input samples. Internally, it will be converted to ``dtype=np.float32`` and if a sparse matrix is provided to a sparse ``csr_matrix``. Returns ------- score : array, shape = [n_samples, n_classes] or [n_samples] The decision function of the input samples. The order of the classes corresponds to that in the attribute :term:`classes_`. Regression and binary classification produce an array of shape [n_samples]. )r r)r_r[r\rrrr_szRFE.decision_function predict_probacCst||j||S)a5Predict class probabilities for X. Parameters ---------- X : {array-like or sparse matrix} of shape (n_samples, n_features) The input samples. Internally, it will be converted to ``dtype=np.float32`` and if a sparse matrix is provided to a sparse ``csr_matrix``. Returns ------- p : array of shape (n_samples, n_classes) The class probabilities of the input samples. The order of the classes corresponds to that in the attribute :term:`classes_`. )r r)r`r[r\rrrr`szRFE.predict_probapredict_log_probacCst||j||S)aPredict class log-probabilities for X. Parameters ---------- X : array of shape [n_samples, n_features] The input samples. Returns ------- p : array of shape (n_samples, n_classes) The class log-probabilities of the input samples. The order of the classes corresponds to that in the attribute :term:`classes_`. )r r)rar[r\rrrraszRFE.predict_log_probacCsdt|jddddS)NTrC)key)Z poor_scorerCZ requires_y)r rr+rrr _more_tagss zRFE._more_tags)N)__name__ __module__ __qualname____doc__rr rrstrcallabler:dict__annotations__r=propertyr>r?r1r!rr/rZr]r^r_r`rarcrrrrr0;sF      T          r0c@sveZdZUdZejeeddddgdgdee gdegdZe e d<e d d d ddddd d d dZ dddZdS)RFECVaRecursive feature elimination with cross-validation to select features. See glossary entry for :term:`cross-validation estimator`. Read more in the :ref:`User Guide `. Parameters ---------- estimator : ``Estimator`` instance A supervised learning estimator with a ``fit`` method that provides information about feature importance either through a ``coef_`` attribute or through a ``feature_importances_`` attribute. step : int or float, default=1 If greater than or equal to 1, then ``step`` corresponds to the (integer) number of features to remove at each iteration. If within (0.0, 1.0), then ``step`` corresponds to the percentage (rounded down) of features to remove at each iteration. Note that the last iteration may remove fewer than ``step`` features in order to reach ``min_features_to_select``. min_features_to_select : int, default=1 The minimum number of features to be selected. This number of features will always be scored, even if the difference between the original feature count and ``min_features_to_select`` isn't divisible by ``step``. .. versionadded:: 0.20 cv : int, cross-validation generator or an iterable, default=None Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 5-fold cross-validation, - integer, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (train, test) splits as arrays of indices. For integer/None inputs, if ``y`` is binary or multiclass, :class:`~sklearn.model_selection.StratifiedKFold` is used. If the estimator is a classifier or if ``y`` is neither binary nor multiclass, :class:`~sklearn.model_selection.KFold` is used. Refer :ref:`User Guide ` for the various cross-validation strategies that can be used here. .. versionchanged:: 0.22 ``cv`` default value of None changed from 3-fold to 5-fold. scoring : str, callable or None, default=None A string (see model evaluation documentation) or a scorer callable object / function with signature ``scorer(estimator, X, y)``. verbose : int, default=0 Controls verbosity of output. n_jobs : int or None, default=None Number of cores to run in parallel while fitting across folds. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. .. versionadded:: 0.18 importance_getter : str or callable, default='auto' If 'auto', uses the feature importance either through a `coef_` or `feature_importances_` attributes of estimator. Also accepts a string that specifies an attribute name/path for extracting feature importance. For example, give `regressor_.coef_` in case of :class:`~sklearn.compose.TransformedTargetRegressor` or `named_steps.clf.feature_importances_` in case of :class:`~sklearn.pipeline.Pipeline` with its last step named `clf`. If `callable`, overrides the default feature importance getter. The callable is passed with the fitted estimator and it should return importance for each feature. .. versionadded:: 0.24 Attributes ---------- classes_ : ndarray of shape (n_classes,) The classes labels. Only available when `estimator` is a classifier. estimator_ : ``Estimator`` instance The fitted estimator used to select features. cv_results_ : dict of ndarrays A dict with keys: split(k)_test_score : ndarray of shape (n_subsets_of_features,) The cross-validation scores across (k)th fold. mean_test_score : ndarray of shape (n_subsets_of_features,) Mean of scores over the folds. std_test_score : ndarray of shape (n_subsets_of_features,) Standard deviation of scores over the folds. .. versionadded:: 1.0 n_features_ : int The number of selected features with cross-validation. n_features_in_ : int Number of features seen during :term:`fit`. Only defined if the underlying estimator exposes such an attribute when fit. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 ranking_ : narray of shape (n_features,) The feature ranking, such that `ranking_[i]` corresponds to the ranking position of the i-th feature. Selected (i.e., estimated best) features are assigned rank 1. support_ : ndarray of shape (n_features,) The mask of selected features. See Also -------- RFE : Recursive feature elimination. Notes ----- The size of all values in ``cv_results_`` is equal to ``ceil((n_features - min_features_to_select) / step) + 1``, where step is the number of features removed at each iteration. Allows NaN/Inf in the input if the underlying estimator does as well. References ---------- .. [1] Guyon, I., Weston, J., Barnhill, S., & Vapnik, V., "Gene selection for cancer classification using support vector machines", Mach. Learn., 46(1-3), 389--422, 2002. Examples -------- The following example shows how to retrieve the a-priori not known 5 informative features in the Friedman #1 dataset. >>> from sklearn.datasets import make_friedman1 >>> from sklearn.feature_selection import RFECV >>> from sklearn.svm import SVR >>> X, y = make_friedman1(n_samples=50, n_features=10, random_state=0) >>> estimator = SVR(kernel="linear") >>> selector = RFECV(estimator, step=1, cv=5) >>> selector = selector.fit(X, y) >>> selector.support_ array([ True, True, True, True, True, False, False, False, False, False]) >>> selector.ranking_ array([1, 1, 1, 1, 1, 6, 4, 3, 2, 5]) rNr5r3Z cv_object)min_features_to_selectcvscoringn_jobsr:r7rr;)r8rnrorpr6rqr9c Cs4||_||_||_||_||_||_||_||_dSr)rr8r9rorpr6rqrn) r,rr8rnrorpr6rqr9rrrr=vs zRFECV.__init__c s4}jdd|dd dd\tjtjd}tjj dj d}d j krzd krnnt t dj |}n t j }tjjjj jd tjdkrtt}ntjd }tt|fd d||D} t| } tj| dd} | ddd} t| t| d} t || |j} tj| j jjdj_j _ j!_!t"j_#j#$| dddddf}i_%tj&|ddj%d<tj'|ddj%d<t(| j dD]}||j%d|d<qS)aFit the RFE model and automatically tune the number of selected features. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the total number of features. y : array-like of shape (n_samples,) Target values (integers for classification, real numbers for regression). groups : array-like of shape (n_samples,) or None, default=None Group labels for the samples used while splitting the dataset into train/test set. Only used in conjunction with a "Group" :term:`cv` instance (e.g., :class:`~sklearn.model_selection.GroupKFold`). .. versionadded:: 0.20 Returns ------- self : object Fitted estimator. ZcsrrrCTrD) classifier)rprrErF)rr7r9r8r6)rqc 3s(|] \}}j||VqdSr)r).0r&r'r$funcr#rr,r%rr szRFECV.fit..r)ZaxisNr<Zmean_test_scoreZstd_test_scoresplitZ _test_score))r@rGrHrIrrorrrrprJr8rLrMr0rnr9r6rrqlistr(r r rxrNarrayrPlenZargmaxr1rUrTrVrr)Z _transformZ cv_results_ZmeanZstdrange)r,r$r%groupsrWrorXr8parallelZscoresZ scores_sumZscores_sum_revZ argmax_idxr7Z scores_revirrtrr1st           z RFECV.fit)N)rdrerfrgr0r:r rrhrirjrkpopr=r1rrrrrms$ )  rm)'rgnumpyrNnumbersrrZjoblibrZutils.metaestimatorsrrZutils._param_validationrr Z utils._tagsr Zutils.validationr Zutils.parallelr r baserrrrZmodel_selectionrZmodel_selection._validationrZmetricsr_baserrr(r/r0rmrrrrs2