
    {Kg$                         d Z ddlZddlmZmZ ddlmZ ddlZddl	m
Z
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mZmZ  G d dee      ZddZy)zGeneric feature selection mixin    N)ABCMetaabstractmethod)
attrgetter)
csc_matrixissparse   )TransformerMixin)_safe_indexingcheck_arraysafe_sqr)_get_output_config)
_safe_tags)_check_feature_names_in_is_pandas_dfcheck_is_fittedc                   B    e Zd ZdZd	dZed        Zd Zd Zd Z	d
dZ
y)SelectorMixina  
    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                 Z    | j                         }|s|S t        j                  |      d   S )a  
        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where)selfindicesmasks      c/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/sklearn/feature_selection/_base.pyget_supportzSelectorMixin.get_support/   s,    ( %%'"t9q(99    c                      y)a  
        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   zSelectorMixin._get_support_maskF   s    r   c           	          t        d|       d   }|dk7  xr t        |      }| j                  |ddt        | d       | d	
      }| j	                  |      S )aB  Reduce 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csr	allow_nan)keyF)dtypeaccept_sparseforce_all_finitecast_to_ndarrayreset)r   r   _validate_datar   
_transform)r   Xoutput_config_dense
preserve_Xs       r   r!   zSelectorMixin.transformR   sp     1MgV(I5J-:J
 !+Dk!BB *N   
 q!!r   c                 R   | j                         }|j                         szt        j                  dt               t        |d      r|j                  ddddf   S t        j                  d|j                        j                  |j                  d   df      S t        ||d      S )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hasattrr3   r   emptyr(   reshapeshaper
   )r   r/   r   s      r   r.   zSelectorMixin._transformp   s    !xxzMMC  q&!vva!e}$88AQWW-55qwwqz1oFFaA..r   c                    t        |      r|j                         }| j                  t        j                  |j
                        j                  dd            }|j                         }t        j                  dgt        j                  |      g      }t        |j                  |j                  |f|j                  d   t        |      dz
  f|j                        }|S | j!                         }t#        |d      }|j%                         |j                  d   k7  rt'        d      |j(                  dk(  r	|dddf   }t        j*                  |j                  d   |j,                  f|j                        }||dd|f<   |S )a  Reverse the transformation operation.

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

        Returns
        -------
        X_r : array of shape [n_samples, n_original_features]
            `X` with columns of zeros inserted where features would have
            been removed by :meth:`transform`.
        r5   r   )r?   r(   Nr4   z,X has a different shape than during fitting.)r   tocscinverse_transformr   diffindptrr>   ravelconcatenatecumsumr   datar   r?   lenr(   r   r   sum
ValueErrorndimzerossize)r   r/   itcol_nonzerosrE   Xtsupports          r   rC   z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                 V    t        |        t        | |      }|| j                            S )a  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_outz#SelectorMixin.get_feature_names_out   s,    ( 	0~Fd..011r   )F)N)__name__
__module____qualname____doc__r   r   r   r!   r.   rC   rV   r   r   r   r   r      s5    4:. 	 	"</ &P2r   r   )	metaclassc                 ^   t        |t              rd|dk(  rSt        | d      rt        d      }n]t        | d      rt        d      }nEt	        d| j
                  j                   d      t        |      }nt        |      st	        d       ||       }||S |dk(  rJ|j                  dk(  rt        j                  |      }|S t        j                  j                  |d	|
      }|S |dk(  r9|j                  dk(  rt        |      }|S t        |      j                  d	      }|S t	        d      )a  
    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`normr5   r   )r7   ordsquarer6   zpValid values for `transform_func` are None, 'norm' and 'square'. Those two transformation are only supported now)
isinstancestrr<   r   rL   	__class__rW   callablerM   r   abslinalgr`   r   rK   )r"   gettertransform_func
norm_orderimportancess        r   _get_feature_importancesrm      sR   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  6
 	
r   )Nr5   )rZ   r9   abcr   r   operatorr   numpyr   scipy.sparser   r   baser	   utilsr
   r   r   utils._set_outputr   utils._tagsr   utils.validationr   r   r   r   rm   r   r   r   <module>rw      sF    %
  '   - # 9 9 2 $ V Vj2$ j2ZDr   