ht\.dZddlmZddlZddlmZddlmZddl m Z m Z dd l m Z mZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl#m$Z$dgZ%dZ&dZ'dZ(dddddddd d!Z)dS)"zBPartial dependence plots for regression and classification models.)IterableN)sparse) mquantiles)_check_feature_names_get_feature_index) is_classifier is_regressor) cartesian) check_array)check_matplotlib_support)_safe_indexing) _safe_assign)_determine_key_type)_get_column_indices)check_is_fitted)Bunch)DecisionTreeRegressor)RandomForestRegressor)NotFittedError)BaseGradientBoosting)BaseHistGradientBoostingpartial_dependencecVt|trt|dkrtdt d|Dstd|d|dkrtd|dkrtdg}t |D]\}} t jt||d }n&#t$r}td |d |d }~wwxYw|s|j d|kr|} nvtt||d |d } t j | d| drtdt j | d| d|d} || t||fS)a Generate a grid of points based on the percentiles of X. The grid is a cartesian product between the columns of ``values``. The ith column of ``values`` consists in ``grid_resolution`` equally-spaced points between the percentiles of the jth column of X. If ``grid_resolution`` is bigger than the number of unique values in the j-th column of X or if the feature is a categorical feature (by inspecting `is_categorical`) , then those unique values will be used instead. Parameters ---------- X : array-like of shape (n_samples, n_target_features) The data. percentiles : tuple of float The percentiles which are used to construct the extreme values of the grid. Must be in [0, 1]. is_categorical : list of bool For each feature, tells whether it is categorical or not. If a feature is categorical, then the values used will be the unique ones (i.e. categories) instead of the percentiles. grid_resolution : int The number of equally spaced points to be placed on the grid for each feature. Returns ------- grid : ndarray of shape (n_points, n_target_features) A value for each feature at each point in the grid. ``n_points`` is always ``<= grid_resolution ** X.shape[1]``. values : list of 1d ndarrays The values with which the grid has been created. The size of each array ``values[j]`` is either ``grid_resolution``, or the number of unique values in ``X[:, j]``, whichever is smaller. r z/'percentiles' must be a sequence of 2 elements.c36K|]}d|cxkodkncVdS)rrN).0xs b/var/www/html/Sam_Eipo/venv/lib/python3.11/site-packages/sklearn/inspection/_partial_dependence.py z_grid_from_X..Qs600qqA{{{{{{{{000000z''percentiles' values must be in [0, 1].rrz9percentiles[0] must be strictly less than percentiles[1].z2'grid_resolution' must be strictly greater than 1.axisz The column #z contains mixed data types. Finding unique categories fail due to sorting. It usually means that the column contains `np.nan` values together with `str` categories. Such use case is not yet supported in scikit-learn.N)probr$ztpercentiles are too close to each other, unable to build the grid. Please choose percentiles that are further apart.T)numendpoint) isinstancerlen ValueErrorall enumeratenpuniquer TypeErrorshaperallcloselinspaceappendr ) X percentilesis_categoricalgrid_resolutionvaluesfeatureis_catuniquesexcr$emp_percentiless r _grid_from_Xr>'sP k8 , ,LK0@0@A0E0EJKKK 00K000 0 0DBCCC1~Q''TUUU!MNNN F%^44"" iq' B B BCCGG   =w===      W]1%77DD)q'2221O{?1-q/ABB  . ;""# D  d V  f $$s-$C C5C00C5ct|||}|jdkr|dd}|S)Nr)%_compute_partial_dependence_recursionndimreshape)estgridfeaturesaveraged_predictionss r _partial_dependence_recursionrHsDDDT8TT A%% 4;;ArBB r"cg}g}t|r|j}nrt|dd}t|dd} |dkr|p| }n |dkr|n| }|9|dkrtd|dkrtdtd|} |D]} t |D]\} } t | | | |  || }|||tj |d z#t$r}td |d}~wwxYw|j d}tj |j }t|r"|jd kr||d }n>t!|r/|j dd kr|d }||d }tj |j }t|r"|jd kr|d d }n>t!|r/|j dd kr|d }|d d }||fS)N predict_probadecision_functionautozCThe estimator has no predict_proba and no decision_function method.z*The estimator has no predict_proba method.z.The estimator has no decision_function method.)column_indexerrr#z0'estimator' parameter must be a fitted estimatorr r@r)r predictgetattrr*copyr,rr3r-meanrr0arrayTrBrCr )rDrErFr4response_method predictionsrGprediction_methodrJrKX_eval new_valuesivariableprede n_sampless r _partial_dependence_bruter^sKCSK_d;; #C) > > > X X XOPPVW W X I(;'')KC9[-22!)))R88 s  9 1! 4 9 9"!n !)))R88 8$899;CC16!;;3;;ArBB s  C 4 :1 = B B 4A63;;ArBB  ,,sA D D=(D88D=rL)g?gffffff?daverage)categorical_features feature_namesrTr5r7methodkindcJ t|t|st|stdt|r4t |jdt jrtdt|ds+tj |st|dt}d} || vr6td |d | t|r|d krtd d } || vr6td |d | | dkr|dkrtdd}|d krFt |tr |jd}n't |t"t$t&frd}nd}|dkrt |tt"t$t&fs7d} td d | |d krd}|dkr"td |t)|ddkrWt jt j|dr0td |jddz t jt3||t jd} t9||jd}dgt;| z}nt jdjj dkr5j!|krtd j!d!|d"fd#| D}nCjj d$vrfd%Dfd&| D}ntd'jd(tEtG|| d)|||\}}|dkr;tI||| ||\}}|j%d*|jdgd+|DR}ntM||| }|j%d*gd,|DR}| dkrtO||-S| d.krtO||/StO|||0S)1aPartial dependence of ``features``. Partial dependence of a feature (or a set of features) corresponds to the average response of an estimator for each possible value of the feature. Read more in the :ref:`User Guide `. .. warning:: For :class:`~sklearn.ensemble.GradientBoostingClassifier` and :class:`~sklearn.ensemble.GradientBoostingRegressor`, the `'recursion'` method (used by default) will not account for the `init` predictor of the boosting process. In practice, this will produce the same values as `'brute'` up to a constant offset in the target response, provided that `init` is a constant estimator (which is the default). However, if `init` is not a constant estimator, the partial dependence values are incorrect for `'recursion'` because the offset will be sample-dependent. It is preferable to use the `'brute'` method. Note that this only applies to :class:`~sklearn.ensemble.GradientBoostingClassifier` and :class:`~sklearn.ensemble.GradientBoostingRegressor`, not to :class:`~sklearn.ensemble.HistGradientBoostingClassifier` and :class:`~sklearn.ensemble.HistGradientBoostingRegressor`. Parameters ---------- estimator : BaseEstimator A fitted estimator object implementing :term:`predict`, :term:`predict_proba`, or :term:`decision_function`. Multioutput-multiclass classifiers are not supported. X : {array-like or dataframe} of shape (n_samples, n_features) ``X`` is used to generate a grid of values for the target ``features`` (where the partial dependence will be evaluated), and also to generate values for the complement features when the `method` is 'brute'. features : array-like of {int, str} The feature (e.g. `[0]`) or pair of interacting features (e.g. `[(0, 1)]`) for which the partial dependency should be computed. categorical_features : array-like of shape (n_features,) or shape (n_categorical_features,), dtype={bool, int, str}, default=None Indicates the categorical features. - `None`: no feature will be considered categorical; - boolean array-like: boolean mask of shape `(n_features,)` indicating which features are categorical. Thus, this array has the same shape has `X.shape[1]`; - integer or string array-like: integer indices or strings indicating categorical features. .. versionadded:: 1.2 feature_names : array-like of shape (n_features,), dtype=str, default=None Name of each feature; `feature_names[i]` holds the name of the feature with index `i`. By default, the name of the feature corresponds to their numerical index for NumPy array and their column name for pandas dataframe. .. versionadded:: 1.2 response_method : {'auto', 'predict_proba', 'decision_function'}, default='auto' Specifies whether to use :term:`predict_proba` or :term:`decision_function` as the target response. For regressors this parameter is ignored and the response is always the output of :term:`predict`. By default, :term:`predict_proba` is tried first and we revert to :term:`decision_function` if it doesn't exist. If ``method`` is 'recursion', the response is always the output of :term:`decision_function`. percentiles : tuple of float, default=(0.05, 0.95) The lower and upper percentile used to create the extreme values for the grid. Must be in [0, 1]. grid_resolution : int, default=100 The number of equally spaced points on the grid, for each target feature. method : {'auto', 'recursion', 'brute'}, default='auto' The method used to calculate the averaged predictions: - `'recursion'` is only supported for some tree-based estimators (namely :class:`~sklearn.ensemble.GradientBoostingClassifier`, :class:`~sklearn.ensemble.GradientBoostingRegressor`, :class:`~sklearn.ensemble.HistGradientBoostingClassifier`, :class:`~sklearn.ensemble.HistGradientBoostingRegressor`, :class:`~sklearn.tree.DecisionTreeRegressor`, :class:`~sklearn.ensemble.RandomForestRegressor`, ) when `kind='average'`. This is more efficient in terms of speed. With this method, the target response of a classifier is always the decision function, not the predicted probabilities. Since the `'recursion'` method implicitly computes the average of the Individual Conditional Expectation (ICE) by design, it is not compatible with ICE and thus `kind` must be `'average'`. - `'brute'` is supported for any estimator, but is more computationally intensive. - `'auto'`: the `'recursion'` is used for estimators that support it, and `'brute'` is used otherwise. Please see :ref:`this note ` for differences between the `'brute'` and `'recursion'` method. kind : {'average', 'individual', 'both'}, default='average' Whether to return the partial dependence averaged across all the samples in the dataset or one value per sample or both. See Returns below. Note that the fast `method='recursion'` option is only available for `kind='average'`. Computing individual dependencies requires using the slower `method='brute'` option. .. versionadded:: 0.24 Returns ------- predictions : :class:`~sklearn.utils.Bunch` Dictionary-like object, with the following attributes. individual : ndarray of shape (n_outputs, n_instances, len(values[0]), len(values[1]), ...) The predictions for all the points in the grid for all samples in X. This is also known as Individual Conditional Expectation (ICE) average : ndarray of shape (n_outputs, len(values[0]), len(values[1]), ...) The predictions for all the points in the grid, averaged over all samples in X (or over the training data if ``method`` is 'recursion'). Only available when ``kind='both'``. values : seq of 1d ndarrays The values with which the grid has been created. The generated grid is a cartesian product of the arrays in ``values``. ``len(values) == len(features)``. The size of each array ``values[j]`` is either ``grid_resolution``, or the number of unique values in ``X[:, j]``, whichever is smaller. ``n_outputs`` corresponds to the number of classes in a multi-class setting, or to the number of tasks for multi-output regression. For classical regression and binary classification ``n_outputs==1``. ``n_values_feature_j`` corresponds to the size ``values[j]``. See Also -------- PartialDependenceDisplay.from_estimator : Plot Partial Dependence. PartialDependenceDisplay : Partial Dependence visualization. Examples -------- >>> X = [[0, 0, 2], [1, 0, 0]] >>> y = [0, 1] >>> from sklearn.ensemble import GradientBoostingClassifier >>> gb = GradientBoostingClassifier(random_state=0).fit(X, y) >>> partial_dependence(gb, features=[0], X=X, percentiles=(0, 1), ... grid_resolution=2) # doctest: +SKIP (array([[-4.52..., 4.52...]]), [array([ 0., 1.])]) z5'estimator' must be a fitted regressor or classifier.rz3Multiclass-multioutput estimators are not supported __array__z allow-nan)force_all_finitedtype)rLrJrKzEresponse_method {} is invalid. Accepted response_method names are {}.z, rLzKThe response_method parameter is ignored for regressors and must be 'auto'.)brute recursionrLz3method {} is invalid. Accepted method names are {}.r`rjzCThe 'recursion' method only applies when 'kind' is set to 'average'riN)GradientBoostingClassifierGradientBoostingRegressorHistGradientBoostingClassifierHistGradientBoostingRegressorrnrrz[Only the following estimators support the 'recursion' method: {}. Try using method='brute'.rKzUWith the 'recursion' method, the response_method must be 'decision_function'. Got {}.F) accept_sliceintzall features must be in [0, {}]rC)rhorder)rPbzeWhen `categorical_features` is a boolean array-like, the array should be of shape (n_features,). Got z elements while `X` contains z features.c g|] }| Srr)ridxras r z&partial_dependence..sTTTC237TTTr")rYOUc2g|]}t|S))rb)r)rcatrbs r rvz&partial_dependence.. s6(((#3mDDD(((r"cg|]}|vSrr)rrucategorical_features_idxs r rvz&partial_dependence..s,47//r"zXExpected `categorical_features` to be an array-like of boolean, integer, or string. Got z instead.r#r@c(g|]}|jdSrr0rvals r rvz&partial_dependence..&s===scil===r"c(g|]}|jdSr~rrs r rvz&partial_dependence..0s - - -scil - - -r")r`r8 individual)rr8)r`rr8)(rr r r*r(classes_r-ndarrayhasattrrissparser objectformatjoinrinitrrrranylessr0asarrayrint32ravelrr)rRrhrdsizer>rr^rCrHr) estimatorr4rFrarbrTr5r7rcrdaccepted_responsesaccepted_methodssupported_classes_recursionfeatures_indices n_featuresr6rEr8rGrUr|s `` @r rrsfI ) $ $R Y(?(?RPQQQYPJy/A!/Dbj$Q$QPNOOO A{ # #Gvq'9'9G Kv F F FG000 f_dii8J.K.KLL   I ?f#<#<    6 %%% A H H "233      y [ U   i!5 6 6 9>;Q FF   %'<>S T   !FFF  $(%%     + '88>II9::99  f $ $1O 1 1 1//5vo/F/F  8%888EAA 6"'(A&& ' ' W>EEagajSTnUUVV VzAx(( egg)M::MJ#3'7#8#88!x(<5III  % *c 1 1#(J66 .+0.."... UTTTCSTTTNN ! ' , ? ?((((/((( $;KNNR,@,FRRR   q*333 LD&,E t-q/- - )k *k)   ==f===    = t-   8/7  - -f - - - y1&AAAA    F;;;;("    r")*__doc__collections.abcrnumpyr-scipyrscipy.stats.mstatsr _pd_utilsrrbaser r utils.extmathr utilsr rrrrrutils.validationrrtreerensembler exceptionsr ensemble._gbr2ensemble._hist_gradient_boosting.gradient_boostingr__all__r>rHr^rrr"r rs HH%$$$$$))))))????????........%%%%%%,,,,,,"""""" ''''''''''''......((((((,,,,,,''''''//////   Y%Y%Y%x   S-S-S-v  Y Y Y Y Y Y Y r"