0Ph,dZddlZddlZddlmZddlmZmZddl m Z ddl m Z m Z mZmZddlmZmZmZmZmZmZdd lmZmZd Zd Zd Zeed ggdgddgeeeeee e!dgeedddgedgdgddgeedddeedddgd dddddddddZ"dS)z&Permutation importance for estimators.N)_generate_indices) check_scoringget_scorer_names)_aggregate_score_dicts)Bunch_safe_indexing check_arraycheck_random_state) HasMethodsIntegralInterval RealNotInt StrOptionsvalidate_params)Paralleldelayedc>||||||S||||S)N) sample_weight)scorer estimatorXyrs j/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/inspection/_permutation_importance.py_weights_scorerrs5 viA]CCCC 6)Q " ""c t|}||jdkrWt|d|jd|} t|| d} t|| d}|t|| d}n|} g} t j| jd} t|D]} || t| dr,| j | |f}| j |_ || | j |<n| | |f| dd|f<| t||| ||t| dt rt#| } nt j| } | S)z+Calculate score when `col_idx` is permuted.rF) random_state bootstrap n_population n_samplesaxisNiloc)r shaperr copynparangerangeshufflehasattrr%indexcolumnsappendr isinstancedictrarray)rrrrcol_idxr n_repeatsr max_samples row_indices X_permutedscores shuffling_idx_cols r_calculate_permutation_scoresr<s&l33LQWQZ'%!    $A{;;; 1k 2 2 2  $*=+ANNNMVVXX FIj.q122M 9  XX]+++ :v & & H/-"89C"(CI69Jz)'2 3 3%/ w0F%GJqqq'z " ofiQ VVWWWW&)T"""'//&!! Mrc||z }ttj|dtj|d|S)aCompute the importances as the decrease in score. Parameters ---------- baseline_score : ndarray of shape (n_features,) The baseline score without permutation. permuted_score : ndarray of shape (n_features, n_repeats) The permuted scores for the `n` repetitions. Returns ------- importances : :class:`~sklearn.utils.Bunch` Dictionary-like object, with the following attributes. importances_mean : ndarray, shape (n_features, ) Mean of feature importance over `n_repeats`. importances_std : ndarray, shape (n_features, ) Standard deviation over `n_repeats`. importances : ndarray, shape (n_features, n_repeats) Raw permutation importance scores. r#)importances_meanimportances_std importances)rr(meanstd)baseline_scorepermuted_scorerAs r_create_importances_bunchrFUsL*!>1K 1555{333   rfitz array-liker>left)closedrright) rrrscoringr4n_jobsrrr5T)prefer_skip_nested_validationg?)rKr4rLrrr5c  tdstddt|}|t jtjjdz ttj stj dzn j dkrtdt| t  t!|   fd t#j dD t t$r fd  DSt' t j S) aPermutation importance for feature evaluation [BRE]_. The :term:`estimator` is required to be a fitted estimator. `X` can be the data set used to train the estimator or a hold-out set. The permutation importance of a feature is calculated as follows. First, a baseline metric, defined by :term:`scoring`, is evaluated on a (potentially different) dataset defined by the `X`. Next, a feature column from the validation set is permuted and the metric is evaluated again. The permutation importance is defined to be the difference between the baseline metric and metric from permutating the feature column. Read more in the :ref:`User Guide `. Parameters ---------- estimator : object An estimator that has already been :term:`fitted` and is compatible with :term:`scorer`. X : ndarray or DataFrame, shape (n_samples, n_features) Data on which permutation importance will be computed. y : array-like or None, shape (n_samples, ) or (n_samples, n_classes) Targets for supervised or `None` for unsupervised. scoring : str, callable, list, tuple, or dict, default=None Scorer to use. If `scoring` represents a single score, one can use: - a single string (see :ref:`scoring_parameter`); - a callable (see :ref:`scoring_callable`) that returns a single value. If `scoring` represents multiple scores, one can use: - a list or tuple of unique strings; - a callable returning a dictionary where the keys are the metric names and the values are the metric scores; - a dictionary with metric names as keys and callables a values. Passing multiple scores to `scoring` is more efficient than calling `permutation_importance` for each of the scores as it reuses predictions to avoid redundant computation. If None, the estimator's default scorer is used. n_repeats : int, default=5 Number of times to permute a feature. n_jobs : int or None, default=None Number of jobs to run in parallel. The computation is done by computing permutation score for each columns and parallelized over the columns. `None` means 1 unless in a :obj:`joblib.parallel_backend` context. `-1` means using all processors. See :term:`Glossary ` for more details. random_state : int, RandomState instance, default=None Pseudo-random number generator to control the permutations of each feature. Pass an int to get reproducible results across function calls. See :term:`Glossary `. sample_weight : array-like of shape (n_samples,), default=None Sample weights used in scoring. .. versionadded:: 0.24 max_samples : int or float, default=1.0 The number of samples to draw from X to compute feature importance in each repeat (without replacement). - If int, then draw `max_samples` samples. - If float, then draw `max_samples * X.shape[0]` samples. - If `max_samples` is equal to `1.0` or `X.shape[0]`, all samples will be used. While using this option may provide less accurate importance estimates, it keeps the method tractable when evaluating feature importance on large datasets. In combination with `n_repeats`, this allows to control the computational speed vs statistical accuracy trade-off of this method. .. versionadded:: 1.0 Returns ------- result : :class:`~sklearn.utils.Bunch` or dict of such instances Dictionary-like object, with the following attributes. importances_mean : ndarray of shape (n_features, ) Mean of feature importance over `n_repeats`. importances_std : ndarray of shape (n_features, ) Standard deviation over `n_repeats`. importances : ndarray of shape (n_features, n_repeats) Raw permutation importance scores. If there are multiple scoring metrics in the scoring parameter `result` is a dict with scorer names as keys (e.g. 'roc_auc') and `Bunch` objects like above as values. References ---------- .. [BRE] :doi:`L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, 2001. <10.1023/A:1010933404324>` Examples -------- >>> from sklearn.linear_model import LogisticRegression >>> from sklearn.inspection import permutation_importance >>> X = [[1, 9, 9],[1, 9, 9],[1, 9, 9], ... [0, 9, 9],[0, 9, 9],[0, 9, 9]] >>> y = [1, 1, 1, 0, 0, 0] >>> clf = LogisticRegression().fit(X, y) >>> result = permutation_importance(clf, X, y, n_repeats=10, ... random_state=0) >>> result.importances_mean array([0.4666..., 0. , 0. ]) >>> result.importances_std array([0.2211..., 0. , 0. ]) r%z allow-nanN)ensure_all_finitedtyper>rz max_samples must be <= n_samples)rK)rLc 3bK|])}tt | V*dS)N)rr<) .0r3rrr5r4 random_seedrrrs r z)permutation_importance..si % %  /-..         % % % % % %rc i|]PttjfdtjdDQS)c,g|]}|Srr)rSr3namer8s r z5permutation_importance...3s"QQQG&/$/QQQrr>)rFr(r2r*r&)rSrXrrDr8s @r z*permutation_importance../st    +t$QQQQQuQWQZ?P?PQQQRR   r)r,r r randintr(iinfoint32maxr0numbersr intr& ValueErrorrrrr*r1rFr2) rrrrKr4rLrrr5rDrTrr8s ``` ` ``@@@@rpermutation_importancerbrst 1f  F [ E E E&l33L&&rx'9'9'='ABBK k7#3 4 4=+ 233 qwqz ! !;<<< 9g 6 6 6F$VY1mLLN $XV $ $ $ % % % % % % % % % % %QWQZ(( % % %  F.$'' K      '     )&9I9IJJJr)#__doc__r_numpyr(ensemble._baggingrmetricsrrmodel_selection._validationrutilsrr r r utils._param_validationr r rrrrutils.parallelrrrr<rFsetcallablelisttupler1rbrrrrosD,, 11111155555555@@@@@@JJJJJJJJJJJJ/.......### 333l: j%))*^D ! Jss++--.. / /       hxD@@@AT"'(&- HXq$v 6 6 6 HZAg 6 6 6 !*#'-:  nKnKnKnK10nKnKnKr