
    -i$                         S r SSKrSSKJrJr  SSKJr  SSKrSSK	J
r
Jr  SSKJr  SSKJrJrJr  SS	KJr  SS
KJr  SSKJrJrJrJr   " S S\\S9rSS jrg)zGeneric feature selection mixin    N)ABCMetaabstractmethod)
attrgetter)
csc_matrixissparse   )TransformerMixin)_safe_indexingcheck_arraysafe_sqr)_get_output_config)get_tags)_check_feature_names_in_is_pandas_dfcheck_is_fittedvalidate_datac                   N    \ rS rSrSrSS jr\S 5       rS rS r	S r
SS	 jrS
rg)SelectorMixin   aM  
Transformer mixin that performs feature selection given a support mask

This mixin provides a feature selector implementation with `transform` and
`inverse_transform` functionality given an implementation of
`_get_support_mask`.

Examples
--------
>>> import numpy as np
>>> from sklearn.datasets import load_iris
>>> from sklearn.base import BaseEstimator
>>> from sklearn.feature_selection import SelectorMixin
>>> class FeatureSelector(SelectorMixin, BaseEstimator):
...    def fit(self, X, y=None):
...        self.n_features_in_ = X.shape[1]
...        return self
...    def _get_support_mask(self):
...        mask = np.zeros(self.n_features_in_, dtype=bool)
...        mask[:2] = True  # select the first two features
...        return mask
>>> X, y = load_iris(return_X_y=True)
>>> FeatureSelector().fit_transform(X, y).shape
(150, 2)
c                 f    U R                  5       nU(       d  U$ [        R                  " U5      S   $ )ak  
Get a mask, or integer index, of the features selected.

Parameters
----------
indices : bool, default=False
    If True, the return value will be an array of integers, rather
    than a boolean mask.

Returns
-------
support : array
    An index that selects the retained features from a feature vector.
    If `indices` is False, this is a boolean array of shape
    [# input features], in which an element is True iff its
    corresponding feature is selected for retention. If `indices` is
    True, this is an integer array of shape [# output features] whose
    values are indices into the input feature vector.
r   )_get_support_masknpnonzero)selfindicesmasks      R/var/www/html/venv/lib/python3.13/site-packages/sklearn/feature_selection/_base.pyget_supportSelectorMixin.get_support4   s-    ( %%'"t;

4(8(;;    c                     g)z
Get the boolean mask indicating which features are selected

Returns
-------
support : boolean array of shape [# input features]
    An element is True iff its corresponding feature is selected for
    retention.
N )r   s    r   r   SelectorMixin._get_support_maskK   s    r    c           
          [        SU S9S   nUS:g  =(       a    [        U5      n[        U USS[        U 5      R                  R
                  (       + USS9nU R                  U5      $ )	zReduce X to the selected features.

Parameters
----------
X : array of shape [n_samples, n_features]
    The input samples.

Returns
-------
X_r : array of shape [n_samples, n_selected_features]
    The input samples with only the selected features.
	transform)	estimatordensedefaultNcsrF)dtypeaccept_sparseensure_all_finiteskip_check_arrayreset)r   r   r   r   
input_tags	allow_nan
_transform)r   Xoutput_config_dense
preserve_Xs       r   r%   SelectorMixin.transformW   so     1MgV(I5J-:J
 "*4.";";"E"EE'
 q!!r    c                 \   U R                  5       nUR                  5       (       d~  [        R                  " S[        5        [        US5      (       a  UR                  SS2SS24   $ [        R                  " SUR                  S9R                  UR                  S   S45      $ [        XSS9$ )z"Reduce X to the selected features.zYNo features were selected: either the data is too noisy or the selection test too strict.ilocNr   r*      axis)r   anywarningswarnUserWarninghasattrr7   r   emptyr*   reshapeshaper
   )r   r2   r   s      r   r1   SelectorMixin._transformv   s    !xxzzMMC  q&!!vva!e}$88AQWW-55qwwqz1oFFaA..r    c                    [        U5      (       a  UR                  5       nU R                  [        R                  " UR
                  5      R                  SS5      5      nUR                  5       n[        R                  " S/[        R                  " U5      /5      n[        UR                  UR                  U4UR                  S   [        U5      S-
  4UR                  S9nU$ U R!                  5       n[#        USS9nUR%                  5       UR                  S   :w  a  ['        S5      eUR(                  S:X  a	  USSS24   n[        R*                  " UR                  S   UR,                  4UR                  S9nXSS2U4'   U$ )a>  Reverse the transformation operation.

Parameters
----------
X : array of shape [n_samples, n_selected_features]
    The input samples.

Returns
-------
X_original : array of shape [n_samples, n_original_features]
    `X` with columns of zeros inserted where features would have
    been removed by :meth:`transform`.
r9   r   )rC   r*   Nr8   z,X has a different shape than during fitting.)r   tocscinverse_transformr   diffindptrrB   ravelconcatenatecumsumr   datar   rC   lenr*   r   r   sum
ValueErrorndimzerossize)r   r2   itcol_nonzerosrJ   Xtsupports          r   rH   SelectorMixin.inverse_transform   s8    A;;	A ''(9(A(A!R(HIB88:L^^aS"))L*A$BCFF+wwqz3v;?3ggB
 I""$&;;=AGGAJ&KLL66Q;$'
AXXqwwqz7<<0@1g:	r    Nc                 R    [        U 5        [        X5      nXR                  5          $ )au  Mask feature names according to selected features.

Parameters
----------
input_features : array-like of str or None, default=None
    Input features.

    - If `input_features` is `None`, then `feature_names_in_` is
      used as feature names in. If `feature_names_in_` is not defined,
      then the following input feature names are generated:
      `["x0", "x1", ..., "x(n_features_in_ - 1)"]`.
    - If `input_features` is an array-like, then `input_features` must
      match `feature_names_in_` if `feature_names_in_` is defined.

Returns
-------
feature_names_out : ndarray of str objects
    Transformed feature names.
)r   r   r   )r   input_featuress     r   get_feature_names_out#SelectorMixin.get_feature_names_out   s(    ( 	0F..011r    r"   )F)N)__name__
__module____qualname____firstlineno____doc__r   r   r   r%   r1   rH   r\   __static_attributes__r"   r    r   r   r      s5    4<. 	 	">/ &P2r    r   )	metaclassc                    [        U[        5      (       ao  US:X  a]  [        U S5      (       a  [        S5      nOg[        U S5      (       a  [        S5      nOJ[	        SU R
                  R                   S35      e[        U5      nO[        U5      (       d  [	        S5      eU" U 5      nUc  U$ US:X  aJ  UR                  S:X  a  [        R                  " U5      nU$ [        R                  R                  US	US
9n U$ US:X  a8  UR                  S:X  a  [        U5      nU$ [        U5      R                  S	S9n U$ [	        S5      e)aF  
Retrieve and aggregate (ndim > 1)  the feature importances
from an estimator. Also optionally applies transformation.

Parameters
----------
estimator : estimator
    A scikit-learn estimator from which we want to get the feature
    importances.

getter : "auto", str or callable
    An attribute or a callable to get the feature importance. If `"auto"`,
    `estimator` is expected to expose `coef_` or `feature_importances`.

transform_func : {"norm", "square"}, default=None
    The transform to apply to the feature importances. By default (`None`)
    no transformation is applied.

norm_order : int, default=1
    The norm order to apply when `transform_func="norm"`. Only applied
    when `importances.ndim > 1`.

Returns
-------
importances : ndarray of shape (n_features,)
    The features importances, optionally transformed.
autocoef_feature_importances_z;when `importance_getter=='auto'`, the underlying estimator z should have `coef_` or `feature_importances_` attribute. Either pass a fitted estimator to feature selector or call fit before calling transform.z4`importance_getter` has to be a string or `callable`normr9   r   )r;   ordsquarer:   zpValid values for `transform_func` are None, 'norm' and 'square'. Those two transformation are only supported now)
isinstancestrr@   r   rQ   	__class__r^   callablerR   r   abslinalgri   r   rP   )r&   gettertransform_func
norm_orderimportancess        r   _get_feature_importancesrv      s^   8 &#Vy'**#G,$:;;#$:; !!*!4!4!=!= > ?00   'FfOPP#K	6	!q &&-K  ))..1*.MK  
8	#q ";/K  #;/333;K  4
 	
r    )Nr9   )rb   r=   abcr   r   operatorr   numpyr   scipy.sparser   r   baser	   utilsr
   r   r   utils._set_outputr   utils._tagsr   utils.validationr   r   r   r   r   rv   r"   r    r   <module>r      sJ    %
  '   - # 9 9 2 " k2$ k2\Dr    