
    /ii6                         d Z ddlmZmZ ddlZddlmZmZm	Z	m
Z
mZ ddlmZ ddlmZmZ ddlmZmZ ddlmZmZmZmZmZ dd	lmZmZmZmZ dd
lm Z  ddl!m"Z"m#Z#  G d deee          Z$dS )z
Sequential feature selection
    )IntegralRealN)BaseEstimatorMetaEstimatorMixin_fit_contextcloneis_classifier)SelectorMixin)check_scoringget_scorer_names)check_cvcross_val_score)MetadataRouterMethodMapping_raise_for_params_routing_enabledprocess_routing)
HasMethodsInterval
RealNotInt
StrOptions)get_tags)check_is_fittedvalidate_datac                   p    e Zd ZU dZ edg          g edh           eeddd           eeddd	          gd ee	ddd	          g ed
dh          gd e e
 e                                egdgdegdZeed<   ddd
dddddZ ed          dd            Zd Zd Z fdZd Z xZS )SequentialFeatureSelectoraA  Transformer that performs Sequential Feature Selection.

    This Sequential Feature Selector adds (forward selection) or
    removes (backward selection) features to form a feature subset in a
    greedy fashion. At each stage, this estimator chooses the best feature to
    add or remove based on the cross-validation score of an estimator. In
    the case of unsupervised learning, this Sequential Feature Selector
    looks only at the features (X), not the desired outputs (y).

    Read more in the :ref:`User Guide <sequential_feature_selection>`.

    .. versionadded:: 0.24

    Parameters
    ----------
    estimator : estimator instance
        An unfitted estimator.

    n_features_to_select : "auto", int or float, default="auto"
        If `"auto"`, the behaviour depends on the `tol` parameter:

        - if `tol` is not `None`, then features are selected while the score
          change does not exceed `tol`.
        - otherwise, 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.

        .. versionadded:: 1.1
           The option `"auto"` was added in version 1.1.

        .. versionchanged:: 1.3
           The default changed from `"warn"` to `"auto"` in 1.3.

    tol : float, default=None
        If the score is not incremented by at least `tol` between two
        consecutive feature additions or removals, stop adding or removing.

        `tol` can be negative when removing features using `direction="backward"`.
        `tol` is required to be strictly positive when doing forward selection.
        It can be useful to reduce the number of features at the cost of a small
        decrease in the score.

        `tol` is enabled only when `n_features_to_select` is `"auto"`.

        .. versionadded:: 1.1

    direction : {'forward', 'backward'}, default='forward'
        Whether to perform forward selection or backward selection.

    scoring : str or callable, default=None
        Scoring method to use for cross-validation. Options:

        - str: see :ref:`scoring_string_names` for options.
        - callable: a scorer callable object (e.g., function) with signature
          ``scorer(estimator, X, y)`` that returns a single value.
          See :ref:`scoring_callable` for details.
        - `None`: the `estimator`'s
          :ref:`default evaluation criterion <scoring_api_overview>` is used.

    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 in a `(Stratified)KFold`,
        - :term:`CV splitter`,
        - An iterable yielding (train, test) splits as arrays of indices.

        For integer/None inputs, if the estimator is a classifier and ``y`` is
        either binary or multiclass,
        :class:`~sklearn.model_selection.StratifiedKFold` is used. In all other
        cases, :class:`~sklearn.model_selection.KFold` is used. These splitters
        are instantiated with `shuffle=False` so the splits will be the same
        across calls.

        Refer :ref:`User Guide <cross_validation>` for the various
        cross-validation strategies that can be used here.

    n_jobs : int, default=None
        Number of jobs to run in parallel. When evaluating a new feature to
        add or remove, the cross-validation procedure is parallel over the
        folds.
        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
        for more details.

    Attributes
    ----------
    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

    n_features_to_select_ : int
        The number of features that were selected.

    support_ : ndarray of shape (n_features,), dtype=bool
        The mask of selected features.

    See Also
    --------
    GenericUnivariateSelect : Univariate feature selector with configurable
        strategy.
    RFE : Recursive feature elimination based on importance weights.
    RFECV : Recursive feature elimination based on importance weights, with
        automatic selection of the number of features.
    SelectFromModel : Feature selection based on thresholds of importance
        weights.

    Examples
    --------
    >>> from sklearn.feature_selection import SequentialFeatureSelector
    >>> from sklearn.neighbors import KNeighborsClassifier
    >>> from sklearn.datasets import load_iris
    >>> X, y = load_iris(return_X_y=True)
    >>> knn = KNeighborsClassifier(n_neighbors=3)
    >>> sfs = SequentialFeatureSelector(knn, n_features_to_select=3)
    >>> sfs.fit(X, y)
    SequentialFeatureSelector(estimator=KNeighborsClassifier(n_neighbors=3),
                              n_features_to_select=3)
    >>> sfs.get_support()
    array([ True, False,  True,  True])
    >>> sfs.transform(X).shape
    (150, 3)
    fitautor      right)closedNneitherforwardbackward	cv_object	estimatorn_features_to_selecttol	directionscoringcvn_jobs_parameter_constraints   )r(   r)   r*   r+   r,   r-   c                h    || _         || _        || _        || _        || _        || _        || _        d S Nr&   )selfr'   r(   r)   r*   r+   r,   r-   s           k/var/www/html/bet.cuttalo.com/ml/venv/lib/python3.11/site-packages/sklearn/feature_selection/_sequential.py__init__z"SequentialFeatureSelector.__init__   s:     #$8!"    F)prefer_skip_nested_validationc                    t          || d           |                                 }t          | |dd|j        j                   }|j        d         }| j        dk    r| j        |dz
  | _        n|dz  | _        nwt          | j        t                    r'| j        |k    rt          d          | j        | _        n6t          | j        t                    rt          || j        z            | _        | j        %| j        d	k     r| j        d
k    rt          d          t          | j        |t#          | j                            }t'          | j                  }t)          j        |t,                    }| j        dk    s| j        d
k    r| j        n	|| j        z
  }	t(          j         }
| j        duo
| j        dk    }t1                      rt3          | dfi | t5          |	          D ]0} | j        |||||fi |\  }}|r||
z
  | j        k     r n|}
d||<   1| j        dk    r| }|| _        | j                                        | _        | S )a  Learn the features to select from X.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            Training vectors, where `n_samples` is the number of samples and
            `n_features` is the number of predictors.

        y : array-like of shape (n_samples,), default=None
            Target values. This parameter may be ignored for
            unsupervised learning.

        **params : dict, default=None
            Parameters to be passed to the underlying `estimator`, `cv`
            and `scorer` objects.

            .. versionadded:: 1.6

                Only available if `enable_metadata_routing=True`,
                which can be set by using
                ``sklearn.set_config(enable_metadata_routing=True)``.
                See :ref:`Metadata Routing User Guide <metadata_routing>` for
                more details.

        Returns
        -------
        self : object
            Returns the instance itself.
        r   csc   )accept_sparseensure_min_featuresensure_all_finiter   r   Nz*n_features_to_select must be < n_features.r   r#   z:tol must be strictly positive when doing forward selection
classifier)shapedtypeTr$   )r   __sklearn_tags__r   
input_tags	allow_nanr?   r(   r)   n_features_to_select_
isinstancer   
ValueErrorr   intr*   r   r,   r	   r'   r   npzerosboolinfr   r   range_get_best_new_feature_scoresupport_sum)r2   Xyparamstags
n_featuresr,   cloned_estimatorcurrent_maskn_iterations	old_scoreis_auto_select_new_feature_idx	new_scores                  r3   r   zSequentialFeatureSelector.fit   s   D 	&$...$$&& !"&/";;
 
 
 WQZ
$..x# .8!^**-71_**18<< 	U(J66 !MNNN)-)BD&&1488 	U),Z$:S-S)T)TD&8DHqLLT^y5P5PL   dgq]4>-J-JKKK 00
 xj=== (F22dn	6Q6Q &&d88 	 VG	-U$2Kv2U
  	3D%226222|$$ 	1 	1A)I)I !QL* *<B* *&OY  I	$9TX#E#E!I,0L))>Z''(=L$%)]%6%6%8%8"r5   c           
      H   t          j        |           }i |D ]j}|                                }	d|	|<   | j        dk    r|	 }	|d d |	f         }
t	          ||
||| j        | j        |                                          |<   kt          fd          }||         fS )NTr$   )r,   r+   r-   rR   c                     |          S r1    )feature_idxscoress    r3   <lambda>zGSequentialFeatureSelector._get_best_new_feature_score.<locals>.<lambda>I  s    f[>Q r5   )key)	rH   flatnonzerocopyr*   r   r+   r-   meanmax)r2   r'   rP   rQ   r,   rV   rR   candidate_feature_indicesr`   candidate_maskX_newr[   ra   s               @r3   rM   z5SequentialFeatureSelector._get_best_new_feature_score2  s     %'NL=$A$A!4 	 	K)..00N*.N;'~++"0aaa'(E"1{# # # dff ; f*Q*Q*Q*QRRR 777r5   c                 .    t          |            | j        S r1   )r   rN   )r2   s    r3   _get_support_maskz+SequentialFeatureSelector._get_support_maskL  s    }r5   c                     t                                                      }t          | j                  j        j        |j        _        t          | j                  j        j        |j        _        |S r1   )superrA   r   r'   rB   rC   sparse)r2   rS   	__class__s     r3   rA   z*SequentialFeatureSelector.__sklearn_tags__P  sQ    ww''))$,T^$<$<$G$Q!!)$.!9!9!D!Kr5   c                    t          |           }|                    | j        t                                          dd                     |                    t	          | j        t          | j                            t                                          dd                     |                    t          | j        | j                  t                                          dd	          
           |S )aj  Get metadata routing of this object.

        Please check :ref:`User Guide <metadata_routing>` on how the routing
        mechanism works.

        .. versionadded:: 1.6

        Returns
        -------
        routing : MetadataRouter
            A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating
            routing information.
        )ownerr   )callercallee)r'   method_mappingr=   split)splitterru   )r+   score)scorerru   )	r   addr'   r   r   r,   r	   r   r+   )r2   routers     r3   get_metadata_routingz.SequentialFeatureSelector.get_metadata_routingV  s      d+++

n(??..eE.JJ 	 	
 	
 	
 	

dg-2O2OPPP(??..eG.LL 	 	
 	
 	
 	

 FFF(??..eG.LL 	 	
 	
 	
 r5   r1   )__name__
__module____qualname____doc__r   r   r   r   r   r   setr   callabler.   dict__annotations__r4   r   r   rM   rl   rA   r|   __classcell__)rp   s   @r3   r   r   "   s        D DN !j%))*Jx  HZAg666HXq$y999!

 hhtT4	BBBC j)Z!899:**SS)9)9););%<%<==xHm"$ $D   $ $    & \&+  b b b	 bH8 8 84            r5   r   )%r   numbersr   r   numpyrH   sklearn.baser   r   r   r   r	   sklearn.feature_selection._baser
   sklearn.metricsr   r   sklearn.model_selectionr   r    sklearn.utils._metadata_requestsr   r   r   r   r   sklearn.utils._param_validationr   r   r   r   sklearn.utils._tagsr   sklearn.utils.validationr   r   r   r_   r5   r3   <module>r      s    # " " " " " " "                  : 9 9 9 9 9 ; ; ; ; ; ; ; ; = = = = = = = =              Y X X X X X X X X X X X ( ( ( ( ( ( C C C C C C C CO O O O O/A= O O O O Or5   