0PhedZddlZddlmZmZddlZddlmZm Z ddl m Z ddl m Z mZddlmZdd lmZmZmZmZmZdd lmZmZmZdd lmZmZdd lmZm Z d dl!m"Z"dZ#dZ$eddgdgdddZ%dZ&eddgdgdddZ'eddgdgdgdgddddddZ(eddgdgdgdgddddddZ)Gdde"e Z*Gd d!e*Z+Gd"d#e*Z,Gd$d%e*Z-Gd&d'e*Z.Gd(d)e*Z/Gd*d+e*Z0dS),zUnivariate features selection.N)IntegralReal)specialstats)issparse) BaseEstimator _fit_context)LabelBinarizer)as_float_array check_array check_X_y safe_masksafe_sqr)Interval StrOptionsvalidate_params) row_normssafe_sparse_dot)check_is_fitted validate_data) SelectorMixinct|d}tj|jj|tj|<|S)z Fixes Issue #1240: NaNs can't be properly compared, so change them to the smallest value of scores's dtype. -inf seems to be unreliable. T)copy)r npfinfodtypeminisnan)scoress o/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/feature_selection/_univariate_selection.py _clean_nansr#s>F . . .F!x 559F28F   Mct|}d|D}tjd|D}tj|}td|D}d|D}t|dz}d|D}||t |z z }d} t |D]\} } | || || z z } | |t |z z} || z } |dz } ||z }| t | z }| t |z }tj|dkd }tj|d j|jkr$|jrtj d |zt||z }tj | }tj| ||}||fS) aPerform a 1-way ANOVA. The one-way ANOVA tests the null hypothesis that 2 or more groups have the same population mean. The test is applied to samples from two or more groups, possibly with differing sizes. Read more in the :ref:`User Guide `. Parameters ---------- *args : {array-like, sparse matrix} Sample1, sample2... The sample measurements should be given as arguments. Returns ------- f_statistic : float The computed F-value of the test. p_value : float The associated p-value from the F-distribution. Notes ----- The ANOVA test has important assumptions that must be satisfied in order for the associated p-value to be valid. 1. The samples are independent 2. Each sample is from a normally distributed population 3. The population standard deviations of the groups are all equal. This property is known as homoscedasticity. If these assumptions are not true for a given set of data, it may still be possible to use the Kruskal-Wallis H-test (`scipy.stats.kruskal`_) although with some loss of power. The algorithm is from Heiman[2], pp.394-7. See ``scipy.stats.f_oneway`` that should give the same results while being less efficient. References ---------- .. [1] Lowry, Richard. "Concepts and Applications of Inferential Statistics". Chapter 14. http://vassarstats.net/textbook .. [2] Heiman, G.W. Research Methods in Statistics. 2002. c,g|]}t|S)r .0as r" zf_oneway..\s , , ,!N1   , , ,r$c(g|]}|jdS)r)shaper(s r"r+zf_oneway..]s#=#=#=1AGAJ#=#=#=r$c3\K|]'}t|dV(dS)raxisN)rsumr(s r" zf_oneway.._s6;;Xa[[__!_,,;;;;;;r$c^g|]*}tj|d+S)rr/)rasarrayr1r(s r"r+zf_oneway..`s.999qAEEqEMM**999r$rcg|]}|dzS)rr')r)ss r"r+zf_oneway..bs333A1a4333r$rrzFeatures %s are constant.)lenrarrayr1float enumeratewherenonzerosizewarningswarn UserWarningr4ravelrfdtrc)args n_classesn_samples_per_class n_samples ss_alldata sums_argssquare_of_sums_alldatasquare_of_sums_argssstotssbnk_sswndfbndfwnmsbmswconstant_features_idxfprobs r"f_onewayrX*sbD I , ,t , , ,D(#=#=#=#=#=>>*++I;;d;;;;;J99D999I ^^q033333 /% 2B2BB BE D$@@1 #A&)`. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The set of regressors that will be tested sequentially. y : array-like of shape (n_samples,) The target vector. Returns ------- f_statistic : ndarray of shape (n_features,) F-statistic for each feature. p_values : ndarray of shape (n_features,) P-values associated with the F-statistic. See Also -------- chi2 : Chi-squared stats of non-negative features for classification tasks. f_regression : F-value between label/feature for regression tasks. Examples -------- >>> from sklearn.datasets import make_classification >>> from sklearn.feature_selection import f_classif >>> X, y = make_classification( ... n_samples=100, n_features=10, n_informative=2, n_clusters_per_class=1, ... shuffle=False, random_state=42 ... ) >>> f_statistic, p_values = f_classif(X, y) >>> f_statistic array([2.2...e+02, 7.0...e-01, 1.6...e+00, 9.3...e-01, 5.4...e+00, 3.2...e-01, 4.7...e-02, 5.7...e-01, 7.5...e-01, 8.9...e-02]) >>> p_values array([7.1...e-27, 4.0...e-01, 1.9...e-01, 3.3...e-01, 2.2...e-02, 5.7...e-01, 8.2...e-01, 4.5...e-01, 3.8...e-01, 7.6...e-01]) csrcsccoo accept_sparsecDg|]}t|kSr')r)r)rNrYrZs r"r+zf_classif..s, : : :Ai16"" # : : :r$)rruniquerX)rYrZrDs`` r" f_classifrfwsTf Q)>)>)> ? ? ?DAq : : : : :RYq\\ : : :D T?r$c<tj|tj}t|}|}||z}|dz}tjd5||z}dddn #1swxYwY|d}|t j|dz |fS) zFast replacement for scipy.stats.chisquare. Version from https://github.com/scipy/scipy/pull/2525 with additional optimizations. rrignore)invalidNrr/r)rr4float64r8errstater1rchdtrc)f_obsf_exprNchisqs r" _chisquarerqs JuBJ / / /E E A E UNE aKE X & & &  II1I  E '.Q.. ..sA##A'*A'ct|dtjtjf}tjt |r|jn|dkrtdtd |}|j ddkr.| }tj d|z |d}t|j|}t |r| }|ddd }|ddd }tj|j|}t'||S) aCompute chi-squared stats between each non-negative feature and class. This score can be used to select the `n_features` features with the highest values for the test chi-squared statistic from X, which must contain only **non-negative integer feature values** such as booleans or frequencies (e.g., term counts in document classification), relative to the classes. If some of your features are continuous, you need to bin them, for example by using :class:`~sklearn.preprocessing.KBinsDiscretizer`. Recall that the chi-square test measures dependence between stochastic variables, so using this function "weeds out" the features that are the most likely to be independent of class and therefore irrelevant for classification. Read more in the :ref:`User Guide `. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Sample vectors. y : array-like of shape (n_samples,) Target vector (class labels). Returns ------- chi2 : ndarray of shape (n_features,) Chi2 statistics for each feature. p_values : ndarray of shape (n_features,) P-values for each feature. See Also -------- f_classif : ANOVA F-value between label/feature for classification tasks. f_regression : F-value between label/feature for regression tasks. Notes ----- Complexity of this algorithm is O(n_classes * n_features). Examples -------- >>> import numpy as np >>> from sklearn.feature_selection import chi2 >>> X = np.array([[1, 1, 3], ... [0, 1, 5], ... [5, 4, 1], ... [6, 6, 2], ... [1, 4, 0], ... [0, 0, 0]]) >>> y = np.array([1, 1, 0, 0, 2, 2]) >>> chi2_stats, p_values = chi2(X, y) >>> chi2_stats array([15.3..., 6.5 , 8.9...]) >>> p_values array([0.0004..., 0.0387..., 0.0116... ]) r_rcrrzInput X must be non-negative.T) sparse_outputrr/)r rrkfloat32anyrdata ValueErrorr fit_transformr-toarrayappendrTr1reshapemeandotrq)rYrZYobserved feature_count class_probexpecteds r"chi2rsHP AU2:rz2JKKKA v!+qvv!q011:8999 T***88;;AwqzQ IIKK Ia!eQQ ' ' 'qsA&&H& ##%%EEqEMM))!R00MQ''2..JvjlM22H h ) ))r$boolean)rYrZcenter force_finiterrct||gdtj\}}|jd}|r|tj|z }|d}t |tjr|n|}tjt|j d||dzzz }nt|j }t||}tj dd 5||z}|tj |z}d d d n #1swxYwY|r?tj|stj|}d ||<|S) aCompute Pearson's r for each features and the target. Pearson's r is also known as the Pearson correlation coefficient. Linear model for testing the individual effect of each of many regressors. This is a scoring function to be used in a feature selection procedure, not a free standing feature selection procedure. The cross correlation between each regressor and the target is computed as:: E[(X[:, i] - mean(X[:, i])) * (y - mean(y))] / (std(X[:, i]) * std(y)) For more on usage see the :ref:`User Guide `. .. versionadded:: 1.0 Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The data matrix. y : array-like of shape (n_samples,) The target vector. center : bool, default=True Whether or not to center the data matrix `X` and the target vector `y`. By default, `X` and `y` will be centered. force_finite : bool, default=True Whether or not to force the Pearson's R correlation to be finite. In the particular case where some features in `X` or the target `y` are constant, the Pearson's R correlation is not defined. When `force_finite=False`, a correlation of `np.nan` is returned to acknowledge this case. When `force_finite=True`, this value will be forced to a minimal correlation of `0.0`. .. versionadded:: 1.1 Returns ------- correlation_coefficient : ndarray of shape (n_features,) Pearson's R correlation coefficients of features. See Also -------- f_regression: Univariate linear regression tests returning f-statistic and p-values. mutual_info_regression: Mutual information for a continuous target. f_classif: ANOVA F-value between label/feature for classification tasks. chi2: Chi-squared stats of non-negative features for classification tasks. Examples -------- >>> from sklearn.datasets import make_regression >>> from sklearn.feature_selection import r_regression >>> X, y = make_regression( ... n_samples=50, n_features=3, n_informative=1, noise=1e-4, random_state=42 ... ) >>> r_regression(X, y) array([-0.15..., 1. , -0.22...]) r^rsrr/T)squaredrridividerjNr7)rrrkr-r isinstancematrixgetA1sqrtrr}rrllinalgnormisfiniteallr ) rYrZrrrGX_meansX_normscorrelation_coefficientnan_masks r" r_regressionr%sP Q)>)>)>bj Q Q QDAq I  !  N &&a&..%/%C%CP'--///')AC666WaZ9OOPPAC..-a33 Hh 7 7 7557*29>>!#4#445555555555555550BK(?@@DDFF08344,/) ""s;(D//D36D3ct||||}|j|rdndz }|dz}tjdd5|d|z z |z}tj|d|}dddn #1swxYwY|rytj|sStj |} tj |j j || <tj |} d|| <d|| <||fS) amUnivariate linear regression tests returning F-statistic and p-values. Quick linear model for testing the effect of a single regressor, sequentially for many regressors. This is done in 2 steps: 1. The cross correlation between each regressor and the target is computed using :func:`r_regression` as:: E[(X[:, i] - mean(X[:, i])) * (y - mean(y))] / (std(X[:, i]) * std(y)) 2. It is converted to an F score and then to a p-value. :func:`f_regression` is derived from :func:`r_regression` and will rank features in the same order if all the features are positively correlated with the target. Note however that contrary to :func:`f_regression`, :func:`r_regression` values lie in [-1, 1] and can thus be negative. :func:`f_regression` is therefore recommended as a feature selection criterion to identify potentially predictive feature for a downstream classifier, irrespective of the sign of the association with the target variable. Furthermore :func:`f_regression` returns p-values while :func:`r_regression` does not. Read more in the :ref:`User Guide `. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The data matrix. y : array-like of shape (n_samples,) The target vector. center : bool, default=True Whether or not to center the data matrix `X` and the target vector `y`. By default, `X` and `y` will be centered. force_finite : bool, default=True Whether or not to force the F-statistics and associated p-values to be finite. There are two cases where the F-statistic is expected to not be finite: - when the target `y` or some features in `X` are constant. In this case, the Pearson's R correlation is not defined leading to obtain `np.nan` values in the F-statistic and p-value. When `force_finite=True`, the F-statistic is set to `0.0` and the associated p-value is set to `1.0`. - when a feature in `X` is perfectly correlated (or anti-correlated) with the target `y`. In this case, the F-statistic is expected to be `np.inf`. When `force_finite=True`, the F-statistic is set to `np.finfo(dtype).max` and the associated p-value is set to `0.0`. .. versionadded:: 1.1 Returns ------- f_statistic : ndarray of shape (n_features,) F-statistic for each feature. p_values : ndarray of shape (n_features,) P-values associated with the F-statistic. See Also -------- r_regression: Pearson's R between label/feature for regression tasks. f_classif: ANOVA F-value between label/feature for classification tasks. chi2: Chi-squared stats of non-negative features for classification tasks. SelectKBest: Select features based on the k highest scores. SelectFpr: Select features based on a false positive rate test. SelectFdr: Select features based on an estimated false discovery rate. SelectFwe: Select features based on family-wise error rate. SelectPercentile: Select features based on percentile of the highest scores. Examples -------- >>> from sklearn.datasets import make_regression >>> from sklearn.feature_selection import f_regression >>> X, y = make_regression( ... n_samples=50, n_features=3, n_informative=1, noise=1e-4, random_state=42 ... ) >>> f_statistic, p_values = f_regression(X, y) >>> f_statistic array([1.2...+00, 2.6...+13, 2.6...+00]) >>> p_values array([2.7..., 1.5..., 1.0...]) rrrrirNr7g?)rr>rrlrrVsfrrisinfrrmaxr ) rYrZrrrdeg_of_freedomcorr_coef_squared f_statisticp_valuesmask_infmask_nans r" f_regressionrs]L+ 1V,VF1qq2N/2 Hh 7 7 7>>'1/@+@ANR 7::k1n==>>>>>>>>>>>>>>> !BK 4488:: !8K(( "): ; ; ? H8K(( # H    s-A66A:=A:cpeZdZUdZdegiZeed<dZe dd dZ d Z fd Z xZ S) _BaseFilterzInitialize the univariate feature selection. Parameters ---------- score_func : callable Function taking two arrays X and y, and returning a pair of arrays (scores, pvalues) or a single array with scores. score_func_parameter_constraintsc||_dSNr)selfrs r"__init__z_BaseFilter.__init__s $r$Tr[Nc|t||ddg}nt|||ddgd\}}||||||}t|tt fr.|\|_|_tj |j|_n||_d|_tj |j|_|S)a Run score function on (X, y) and get the appropriate features. Parameters ---------- X : array-like of shape (n_samples, n_features) The training input samples. y : array-like of shape (n_samples,) or None The target values (class labels in classification, real numbers in regression). If the selector is unsupervised then `y` can be set to `None`. Returns ------- self : object Returns the instance itself. Nr_r`rbT)rc multi_output) r _check_paramsrrlisttuplescores_pvalues_rr4)rrYrZscore_func_rets r"fitz_BaseFilter.fits$ 9dAeU^DDDAA a5%.tDAq 1a   A.. ntUm 4 4 !*8 'DL$-Jt}55DMM)DL DMz$,//  r$cdSrr'rrYrZs r"rz_BaseFilter._check_paramsEs r$cxt}d|j_d|j_|S)NT)super__sklearn_tags__ target_tagsrequired input_tagssparsertags __class__s r"rz_BaseFilter.__sklearn_tags__Hs2ww''))$(!!% r$r)__name__ __module__ __qualname____doc__callablerdict__annotations__rr rrr __classcell__rs@r"rrs%18*#=D===%%%\555###65#J   r$rc~eZdZUdZiejdeedddgiZee d<e fdd fd Z d Z fd Z xZS) SelectPercentilea Select features according to a percentile of the highest scores. Read more in the :ref:`User Guide `. Parameters ---------- score_func : callable, default=f_classif Function taking two arrays X and y, and returning a pair of arrays (scores, pvalues) or a single array with scores. Default is f_classif (see below "See Also"). The default function only works with classification tasks. .. versionadded:: 0.18 percentile : int, default=10 Percent of features to keep. Attributes ---------- scores_ : array-like of shape (n_features,) Scores of features. pvalues_ : array-like of shape (n_features,) p-values of feature scores, None if `score_func` returned only scores. n_features_in_ : int Number of features seen during :term:`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 See Also -------- f_classif : ANOVA F-value between label/feature for classification tasks. mutual_info_classif : Mutual information for a discrete target. chi2 : Chi-squared stats of non-negative features for classification tasks. f_regression : F-value between label/feature for regression tasks. mutual_info_regression : Mutual information for a continuous target. SelectKBest : Select features based on the k highest scores. SelectFpr : Select features based on a false positive rate test. SelectFdr : Select features based on an estimated false discovery rate. SelectFwe : Select features based on family-wise error rate. GenericUnivariateSelect : Univariate feature selector with configurable mode. Notes ----- Ties between features with equal scores will be broken in an unspecified way. This filter supports unsupervised feature selection that only requests `X` for computing the scores. Examples -------- >>> from sklearn.datasets import load_digits >>> from sklearn.feature_selection import SelectPercentile, chi2 >>> X, y = load_digits(return_X_y=True) >>> X.shape (1797, 64) >>> X_new = SelectPercentile(chi2, percentile=10).fit_transform(X, y) >>> X_new.shape (1797, 7) percentilerdbothclosedr )rcZt|||_dSNr)rrr)rrrrs r"rzSelectPercentile.__init__s) J///$r$cbt||jdkr-tjt |jt S|jdkr-tjt |jt St|j}tj|d|jz }||k}tj ||kd}t |rKtt ||jzdz }|d|| z }d||<|S)NrrhrT) rrronesr8rboolzerosr#r<intr1)rr! thresholdmaskties max_feats kept_tiess r"_get_support_maskz"SelectPercentile._get_support_masks  ?c ! !73t|,,D999 9 _ ! !8C --T::: :T\**M&#*?@@  !x)+,,Q/ t99 #CKK$/9C?@@I5y488::556I"DO r$c`t}d|j_|SNFrrrrrs r"rz!SelectPercentile.__sklearn_tags__(ww''))$)! r$)rrrrrrrrrrrfrrrrrs@r"rrRsDDL$  ,$xxaV<<<=$$D #,%2%%%%%%%&r$rc eZdZUdZiejdedheedddgiZe e d<e fd d fd Z d Z d ZfdZxZS) SelectKBesta Select features according to the k highest scores. Read more in the :ref:`User Guide `. Parameters ---------- score_func : callable, default=f_classif Function taking two arrays X and y, and returning a pair of arrays (scores, pvalues) or a single array with scores. Default is f_classif (see below "See Also"). The default function only works with classification tasks. .. versionadded:: 0.18 k : int or "all", default=10 Number of top features to select. The "all" option bypasses selection, for use in a parameter search. Attributes ---------- scores_ : array-like of shape (n_features,) Scores of features. pvalues_ : array-like of shape (n_features,) p-values of feature scores, None if `score_func` returned only scores. n_features_in_ : int Number of features seen during :term:`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 See Also -------- f_classif: ANOVA F-value between label/feature for classification tasks. mutual_info_classif: Mutual information for a discrete target. chi2: Chi-squared stats of non-negative features for classification tasks. f_regression: F-value between label/feature for regression tasks. mutual_info_regression: Mutual information for a continuous target. SelectPercentile: Select features based on percentile of the highest scores. SelectFpr : Select features based on a false positive rate test. SelectFdr : Select features based on an estimated false discovery rate. SelectFwe : Select features based on family-wise error rate. GenericUnivariateSelect : Univariate feature selector with configurable mode. Notes ----- Ties between features with equal scores will be broken in an unspecified way. This filter supports unsupervised feature selection that only requests `X` for computing the scores. Examples -------- >>> from sklearn.datasets import load_digits >>> from sklearn.feature_selection import SelectKBest, chi2 >>> X, y = load_digits(return_X_y=True) >>> X.shape (1797, 64) >>> X_new = SelectKBest(chi2, k=20).fit_transform(X, y) >>> X_new.shape (1797, 20) rNrrNleftrrr)rNcZt|||_dSr)rrrN)rrrNrs r"rzSelectKBest.__init__ s) J///r$ct|jtsC|j|jdkr/t jd|jd|jdddSdSdS)Nrzk=z is greater than n_features=z$. All the features will be returned.)rrNstrr-r?r@rs r"rzSelectKBest._check_params s$&#&& 46AGAJ+>+> M5TV55555       +>+>r$ct||jdkr%tj|jjt S|jdkr%tj|jjt St|j}tj|jt }d|tj |d|j d<|S)Nrrhrr mergesort)kind) rrNrrrr-rrr#argsort)rr!rs r"rzSelectKBest._get_support_masks 6U??74<-T::: : Vq[[8DL.d;;; ; ..F8FL555DEFDF555tvgii@ AKr$c`t}d|j_|Srrrs r"rzSelectKBest.__sklearn_tags__$rr$)rrrrrrrrrrrrfrrrrrrs@r"rrsFFP$  ,$ jj%!!88Haf#M#M#M N$$D #," r$rcteZdZUdZiejdeedddgiZee d<e fdd fd Z d Z xZ S) SelectFpraFilter: Select the pvalues below alpha based on a FPR test. FPR test stands for False Positive Rate test. It controls the total amount of false detections. Read more in the :ref:`User Guide `. Parameters ---------- score_func : callable, default=f_classif Function taking two arrays X and y, and returning a pair of arrays (scores, pvalues). Default is f_classif (see below "See Also"). The default function only works with classification tasks. alpha : float, default=5e-2 Features with p-values less than `alpha` are selected. Attributes ---------- scores_ : array-like of shape (n_features,) Scores of features. pvalues_ : array-like of shape (n_features,) p-values of feature scores. n_features_in_ : int Number of features seen during :term:`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 See Also -------- f_classif : ANOVA F-value between label/feature for classification tasks. chi2 : Chi-squared stats of non-negative features for classification tasks. mutual_info_classif: Mutual information for a discrete target. f_regression : F-value between label/feature for regression tasks. mutual_info_regression : Mutual information for a continuous target. SelectPercentile : Select features based on percentile of the highest scores. SelectKBest : Select features based on the k highest scores. SelectFdr : Select features based on an estimated false discovery rate. SelectFwe : Select features based on family-wise error rate. GenericUnivariateSelect : Univariate feature selector with configurable mode. Examples -------- >>> from sklearn.datasets import load_breast_cancer >>> from sklearn.feature_selection import SelectFpr, chi2 >>> X, y = load_breast_cancer(return_X_y=True) >>> X.shape (569, 30) >>> X_new = SelectFpr(chi2, alpha=0.01).fit_transform(X, y) >>> X_new.shape (569, 16) alpharrrrr皙?rcZt|||_dSrrrrrrrrs r"rzSelectFpr.__init__p) J/// r$c@t||j|jkSr)rrrrs r"rzSelectFpr._get_support_maskts}tz))r$rrrrrrrrrrrfrrrrs@r"rr*s>>@$  ,$((4Af5556$$D #,d*******r$rcteZdZUdZiejdeedddgiZee d<e fdd fd Z d Z xZ S) SelectFdra6 Filter: Select the p-values for an estimated false discovery rate. This uses the Benjamini-Hochberg procedure. ``alpha`` is an upper bound on the expected false discovery rate. Read more in the :ref:`User Guide `. Parameters ---------- score_func : callable, default=f_classif Function taking two arrays X and y, and returning a pair of arrays (scores, pvalues). Default is f_classif (see below "See Also"). The default function only works with classification tasks. alpha : float, default=5e-2 The highest uncorrected p-value for features to keep. Attributes ---------- scores_ : array-like of shape (n_features,) Scores of features. pvalues_ : array-like of shape (n_features,) p-values of feature scores. n_features_in_ : int Number of features seen during :term:`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 See Also -------- f_classif : ANOVA F-value between label/feature for classification tasks. mutual_info_classif : Mutual information for a discrete target. chi2 : Chi-squared stats of non-negative features for classification tasks. f_regression : F-value between label/feature for regression tasks. mutual_info_regression : Mutual information for a continuous target. SelectPercentile : Select features based on percentile of the highest scores. SelectKBest : Select features based on the k highest scores. SelectFpr : Select features based on a false positive rate test. SelectFwe : Select features based on family-wise error rate. GenericUnivariateSelect : Univariate feature selector with configurable mode. References ---------- https://en.wikipedia.org/wiki/False_discovery_rate Examples -------- >>> from sklearn.datasets import load_breast_cancer >>> from sklearn.feature_selection import SelectFdr, chi2 >>> X, y = load_breast_cancer(return_X_y=True) >>> X.shape (569, 30) >>> X_new = SelectFdr(chi2, alpha=0.01).fit_transform(X, y) >>> X_new.shape (569, 16) rrrrrrrrcZt|||_dSrrrs r"rzSelectFdr.__init__rr$c~t|t|j}tj|j}||t |j|z tjd|dzzk}|jdkr tj |jtS|j| kS)Nrrrh) rr8rrsortr:raranger> zeros_likerr)r n_featuressvselecteds r"rzSelectFdr._get_support_masks'' WT] # # % ##j029Q Q3O3OO O  =A  =d;;; ;} ..r$rrs@r"rrzsBBH$  ,$((4Af5556$$D #,d / / / / / / /r$rcteZdZUdZiejdeedddgiZee d<e fdd fd Z d Z xZ S) SelectFweaFilter: Select the p-values corresponding to Family-wise error rate. Read more in the :ref:`User Guide `. Parameters ---------- score_func : callable, default=f_classif Function taking two arrays X and y, and returning a pair of arrays (scores, pvalues). Default is f_classif (see below "See Also"). The default function only works with classification tasks. alpha : float, default=5e-2 The highest uncorrected p-value for features to keep. Attributes ---------- scores_ : array-like of shape (n_features,) Scores of features. pvalues_ : array-like of shape (n_features,) p-values of feature scores. n_features_in_ : int Number of features seen during :term:`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 See Also -------- f_classif : ANOVA F-value between label/feature for classification tasks. chi2 : Chi-squared stats of non-negative features for classification tasks. f_regression : F-value between label/feature for regression tasks. SelectPercentile : Select features based on percentile of the highest scores. SelectKBest : Select features based on the k highest scores. SelectFpr : Select features based on a false positive rate test. SelectFdr : Select features based on an estimated false discovery rate. GenericUnivariateSelect : Univariate feature selector with configurable mode. Examples -------- >>> from sklearn.datasets import load_breast_cancer >>> from sklearn.feature_selection import SelectFwe, chi2 >>> X, y = load_breast_cancer(return_X_y=True) >>> X.shape (569, 30) >>> X_new = SelectFwe(chi2, alpha=0.01).fit_transform(X, y) >>> X_new.shape (569, 15) rrrrrrrrcZt|||_dSrrrs r"rzSelectFwe.__init__rr$cjt||j|jt|jz kSr)rrrr8rs r"rzSelectFwe._get_support_masks.}tzC ,>,>>>>r$rrs@r"r r s99v$  ,$((4Af5556$$D #,d???????r$r ceZdZUdZeeeeedZ e e d<ie j eee geedddedhgd Z e e d <efd d d fd ZdZfdZdZdZxZS)GenericUnivariateSelecta Univariate feature selector with configurable strategy. Read more in the :ref:`User Guide `. Parameters ---------- score_func : callable, default=f_classif Function taking two arrays X and y, and returning a pair of arrays (scores, pvalues). For modes 'percentile' or 'kbest' it can return a single array scores. mode : {'percentile', 'k_best', 'fpr', 'fdr', 'fwe'}, default='percentile' Feature selection mode. Note that the `'percentile'` and `'kbest'` modes are supporting unsupervised feature selection (when `y` is `None`). param : "all", float or int, default=1e-5 Parameter of the corresponding mode. Attributes ---------- scores_ : array-like of shape (n_features,) Scores of features. pvalues_ : array-like of shape (n_features,) p-values of feature scores, None if `score_func` returned scores only. n_features_in_ : int Number of features seen during :term:`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 See Also -------- f_classif : ANOVA F-value between label/feature for classification tasks. mutual_info_classif : Mutual information for a discrete target. chi2 : Chi-squared stats of non-negative features for classification tasks. f_regression : F-value between label/feature for regression tasks. mutual_info_regression : Mutual information for a continuous target. SelectPercentile : Select features based on percentile of the highest scores. SelectKBest : Select features based on the k highest scores. SelectFpr : Select features based on a false positive rate test. SelectFdr : Select features based on an estimated false discovery rate. SelectFwe : Select features based on family-wise error rate. Examples -------- >>> from sklearn.datasets import load_breast_cancer >>> from sklearn.feature_selection import GenericUnivariateSelect, chi2 >>> X, y = load_breast_cancer(return_X_y=True) >>> X.shape (569, 30) >>> transformer = GenericUnivariateSelect(chi2, mode='k_best', param=20) >>> X_new = transformer.fit_transform(X, y) >>> X_new.shape (569, 20) )rk_bestfprfdrfwe_selection_modesrNrrr)modeparamrrgh㈵>cht|||_||_dSr)rrrr)rrrrrs r"rz GenericUnivariateSelect.__init__vs0 J///  r$c|j|j|j}|}|d|jdi|d|ji|S)Nrrrr')rrr_get_param_namesremove set_paramsr)rselectorpossible_paramss r"_make_selectorz&GenericUnivariateSelect._make_selector{sq34(3tOOO#3355|,,,??q14:>???r$cdt}ddg|j_|S)Nrkrv)rrtransformer_tagspreserves_dtypers r"rz(GenericUnivariateSelect.__sklearn_tags__s-ww''))1:I0F- r$cV|||dSr)rrrs r"rz%GenericUnivariateSelect._check_paramss* ++Aq11111r$ct||}|j|_|j|_|Sr)rrrrr)rrs r"rz)GenericUnivariateSelect._get_support_masksG&&(( M<))+++r$)rrrrrrrrr rrrrrrsetkeysrrrfrrrrrrrs@r"r r 'sS>>B' d$  ,$CC 0 5 5 7 78899:(4D888**eW:M:MN$$$D #,\    222,,,,,,,r$r )1rr?numbersrrnumpyrscipyrr scipy.sparserbaser r preprocessingr utilsr r rrrutils._param_validationrrr utils.extmathrrutils.validationrr_baserr#rXrfrqrrrrrrrrr r r'r$r"r/s&$$ """""""" !!!!!!........******OOOOOOOOOOOOOOKKKKKKKKKK66666666========    &JJJZO ,^#' ...b///&O ,^#' Y*Y*Y*xO ,^+"  #'"&D]#]#]#]#]#@O ,^+"  #'"&Dr!r!r!r!r!r<<<<<-<<<Dfffff{fffRlllll+lll^M*M*M*M*M* M*M*M*`X/X/X/X/X/ X/X/X/vH?H?H?H?H? H?H?H?dm,m,m,m,m,km,m,m,m,m,r$