MpjSrSSKJr SSKrSSKJr SSKJr SSK J r J r SSK J r SSKJr SS KJr SS KJrJr SS KJr SS KJrJrJr SS KJrJrJr SSKJ r SSK!J"r"J#r#J$r$J%r%J&r& SSK'J(r( SSK)J*r* SSK+J,r,J-r- S/r.Sr/Sr0S,Sjr1\&"\""SS/5\""SS/5\""SS/5/SS/S\#\2/SS/SS/SS/\%"1Sk5/\3/\$"\#SSSS 9/\%"1S!k5/\%"1S"k5/\4S/S#. S$S%9SSSS&S'S(SS&S)S*. S+j5r5g)-zBPartial dependence plots for regression and classification models.)IterableN)sparse) mquantiles) is_classifier is_regressor)RandomForestRegressor)BaseGradientBoosting)BaseHistGradientBoosting)_check_feature_names_get_feature_index)DecisionTreeRegressor)Bunch_safe_indexing check_array)_determine_key_type_get_column_indices _safe_assign)check_matplotlib_support) HasMethodsIntegralInterval StrOptionsvalidate_params)_get_response_values) cartesian)_check_sample_weightcheck_is_fittedpartial_dependencec [U[5(a[U5S:wa [S5e[ SU55(d [S5eUSUS:a [S5eUS::a [S5eS nUR 5VVs0sH upgXe"U5_M nnn[ S UR555(a4S RS UR 555n[S U35e/n [U5HupX;aXJn O[R"[X SS95n U (dU RSU:aU n O][[X SS9USS9n[R "USUS5(a [S5e[R""USUSUSS9n U R%U 5 M ['U 5U 4$s snnf![an[SU S35UeSnAff=f)aGenerate 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. custom_values: dict Mapping from column index of X to an array-like of values where the partial dependence should be calculated for that 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``, the number of unique values in ``X[:, j]``, if j is not in ``custom_range``. If j is in ``custom_range``, then it is the length of ``custom_range[j]``. z/'percentiles' must be a sequence of 2 elements.c3L# UHnSUs=:*=(a S:*Os v M g7f)rN).0xs b/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/sklearn/inspection/_partial_dependence.py _grid_from_X..Zs0KqqA{{{{Ks"$z''percentiles' values must be in [0, 1].rr"z9percentiles[0] must be strictly less than percentiles[1].z2'grid_resolution' must be strictly greater than 1.ch[SU55(a[OSn[R"XS9$)Nc3B# UHn[U[5v M g7fN) isinstancestrr$vs r&r'?_grid_from_X.._convert_custom_values..dsA&QjC00&s)dtype)anyobjectnpasarray)valuesr1s r&_convert_custom_values,_grid_from_X.._convert_custom_valuesbs(A&AAAtzz&..c3># UHoRS:gv M g7f)r"Nndimr.s r&r'r(hs 7 6166Q; 6s, c3p# UH,upURS:wdMSUSURS3v M. g7f)r"zFeature z: z dimensionsNr;)r$kr/s r&r'r(is9! -vv{ 0hqcAFF8; /-s66zBThe custom grid for some features is not a one-dimensional array. 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)probrAztpercentiles are too close to each other, unable to build the grid. Please choose percentiles that are further apart.T)numendpoint)r,rlen ValueErrorallitemsr2r6join enumerater4uniquer TypeErrorshaperallcloselinspaceappendr)X percentilesis_categoricalgrid_resolution custom_valuesr7r?r/ error_stringr6featureis_catrAuniquesexcemp_percentiless r& _grid_from_Xr\+s4Z k8 , ,K0@A0EJKK 0K0 0 0BCC1~Q'TUU!MNN/ ?L>Q>Q>ST>SdaQ.q11>SMT 7 4 4 6 777yy! %++-!   Pn   F%^4  # )D ))N1A$FGq)O;#-"1A6[q#;;q1?13EFF$2 {{#A&#A&'!   dO5R V f $$sU. !"7),AA   sGG G<'G77G<clURX5nURS:XaURSS5nU$)aCalculate partial dependence via the recursion method. The recursion method is in particular enabled for tree-based estimators. For each `grid` value, a weighted tree traversal is performed: if a split node involves an input feature of interest, the corresponding left or right branch is followed; otherwise both branches are followed, each branch being weighted by the fraction of training samples that entered that branch. Finally, the partial dependence is given by a weighted average of all the visited leaves values. This method is more efficient in terms of speed than the `'brute'` method (:func:`~sklearn.inspection._partial_dependence._partial_dependence_brute`). However, here, the partial dependence computation is done explicitly with the `X` used during training of `est`. Parameters ---------- est : BaseEstimator A fitted estimator object implementing :term:`predict` or :term:`decision_function`. Multioutput-multiclass classifiers are not supported. Note that `'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`, ). grid : array-like of shape (n_points, n_target_features) The grid of feature values for which the partial dependence is calculated. Note that `n_points` is the number of points in the grid and `n_target_features` is the number of features you are doing partial dependence at. 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. Returns ------- averaged_predictions : array-like of shape (n_targets, n_points) The averaged predictions for the given `grid` of features values. Note that `n_targets` is the number of targets (e.g. 1 for binary classification, `n_tasks` for multi-output regression, and `n_classes` for multiclass classification) and `n_points` is the number of points in the `grid`. r")%_compute_partial_dependence_recursionr<reshape)estgridfeaturesaveraged_predictionss r&_partial_dependence_recursionres?bDDTT  A% 4;;ArB r9c /n/nUS:Xa[U5(aSOSS/nUR5nUHfn [U5Hup[XU U S9 M [ XUS9upUR U 5 UR [ R"U SUS95 Mh URSn[ R"U5Rn[U5(a#URS :XaURUS 5nO:[U5(a*URSS :XaUS nURUS 5n[ R"U5RnURS :XaURS S 5nXv4$) aF Calculate partial dependence via the brute force method. The brute method explicitly averages the predictions of an estimator over a grid of feature values. For each `grid` value, all the samples from `X` have their variables of interest replaced by that specific `grid` value. The predictions are then made and averaged across the samples. This method is slower than the `'recursion'` (:func:`~sklearn.inspection._partial_dependence._partial_dependence_recursion`) version for estimators with this second option. However, with the `'brute'` force method, the average will be done with the given `X` and not the `X` used during training, as it is done in the `'recursion'` version. Therefore the average can always accept `sample_weight` (even when the estimator was fitted without). Parameters ---------- est : BaseEstimator A fitted estimator object implementing :term:`predict`, :term:`predict_proba`, or :term:`decision_function`. Multioutput-multiclass classifiers are not supported. grid : array-like of shape (n_points, n_target_features) The grid of feature values for which the partial dependence is calculated. Note that `n_points` is the number of points in the grid and `n_target_features` is the number of features you are doing partial dependence at. 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. X : array-like of shape (n_samples, n_features) `X` is used to generate values for the complement features. That is, for each value in `grid`, the method will average the prediction of each sample from `X` having that grid value for `features`. 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. sample_weight : array-like of shape (n_samples,), default=None Sample weights are used to calculate weighted means when averaging the model output. If `None`, then samples are equally weighted. Note that `sample_weight` does not change the individual predictions. Returns ------- averaged_predictions : array-like of shape (n_targets, n_points) The averaged predictions for the given `grid` of features values. Note that `n_targets` is the number of targets (e.g. 1 for binary classification, `n_tasks` for multi-output regression, and `n_classes` for multiclass classification) and `n_points` is the number of points in the `grid`. predictions : array-like The predictions for the given `grid` of features values over the samples from `X`. For non-multioutput regression and binary classification the shape is `(n_instances, n_points)` and for multi-output regression and multiclass classification the shape is `(n_targets, n_instances, n_points)`, where `n_targets` is the number of targets (`n_tasks` for multi-output regression, and `n_classes` for multiclass classification), `n_instances` is the number of instances in `X`, and `n_points` is the number of points in the `grid`. autopredict predict_probadecision_function)column_indexer)response_methodr)rAweightsr r^r")rcopyrJrrrPr4averagerMarrayTr<r`r)rarbrcrQrl sample_weight predictionsrdX_eval new_valuesivariablepred_ n_sampless r&_partial_dependence_bruter{snPK& %c**IBU0V VVXF $X.KA Ax H/'sOT4 ##BJJt!]$ST  I((;'))KC[--2!)))R8 s   1 1! 4 9"!n !)))R8 88$89;;  A% 4;;ArB  ,,r9fitrhrirjz array-likez sparse matrix>rgrirjr"left)closed>rgbrute recursion>bothro individual) estimatorrQrcrrcategorical_features feature_namesrlrRrTmethodkindrUT)prefer_skip_nested_validationrg)g?gffffff?dro) rrrrrlrRrTrUrrc  [U5 [U5(d[U5(d [S5e[U5(a7[ UR S[ R5(a [S5e[US5(d*[R"U5(d[US[S9n[U5(aUS:wa [S5eU S :waU S :Xa [S 5eS n U S :XaUb [S 5eU S:XaPUbS n OJ[ U[5(aURcS n O%[ U[[ ["45(aS n OS n U S :Xam[ U[[[ ["45(d+Sn [SR%SR'U 555eUS:XaSnUS:wa[SUS35eUb [)X15n[+USS9S:XaO[ R,"[ R."US55(a[SUR0SS- S35e[ R2"[5X5[ R6SS9R95n [;X5nUR0SnUcS/[=U 5-nO[ R2"U5nUR>S:Xa [S5eUR@RBS:XaBUR>U:wa[SUR>SUS 35eU Vs/sHnUUPM nnOcUR@RBS!;a0UVs/sH n[EUUS"9PM nnU Vs/sHnUU;PM nnO[S#UR@S$35eU =(d 0n [ U[F[H45(aU/n[KXU5HCunnnU(aM[MUUSS%9R@RBS&;dM5[S'U<S(35e [MXSS%9n[OU5VVs0sH unnUU ;dMUU RQU5_M" nnn[SUUUUU5unnU S :XaQ[UUUXXc5unnURV"S)UR0S/UVs/sHnUR0SPM snQ76nO [YUUU 5nURV"S)/UVs/sHnUR0SPM snQ76n[[US*9nU S :XaUUS 'U$U S+:XaWUS+'U$UUS 'WUS+'U$s snfs snfs snfs snnfs snfs snf),a1!Partial 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 :ref:`sphx_glr_auto_examples_inspection_plot_partial_dependence.py` and 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, sparse matrix 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, bool} or int or str The feature (e.g. `[0]`) or pair of interacting features (e.g. `[(0, 1)]`) for which the partial dependency should be computed. sample_weight : array-like of shape (n_samples,), default=None Sample weights are used to calculate weighted means when averaging the model output. If `None`, then samples are equally weighted. If `sample_weight` is not `None`, then `method` will be set to `'brute'`. Note that `sample_weight` is ignored for `kind='individual'`. .. versionadded:: 1.3 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]. This parameter is overridden by `custom_values` if that parameter is set. grid_resolution : int, default=100 The number of equally spaced points on the grid, for each target feature. This parameter is overridden by `custom_values` if that parameter is set. custom_values : dict A dictionary mapping the index of an element of `features` to an array of values where the partial dependence should be calculated for that feature. Setting a range of values for a feature overrides `grid_resolution` and `percentiles`. See :ref:`how to use partial_dependence ` for an example of how this parameter can be used. .. versionadded:: 1.7 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. If `sample_weight` is not `None`, then `'brute'` is used regardless of the estimator. 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'` and `sample_weights=None`. Computing individual dependencies and doing weighted averages requires using the slower `method='brute'`. .. 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). Only available when `kind='individual'` or `kind='both'`. 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='average'` or `kind='both'`. grid_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 `grid_values` where `len(grid_values) == len(features)`. The size of each array `grid_values[j]` is either `grid_resolution`, or the number of unique values in `X[:, j]`, whichever is smaller. .. versionadded:: 1.3 `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 `grid_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)ensure_all_finiter1rgzKThe response_method parameter is ignored for regressors and must be 'auto'.rorzCThe 'recursion' method only applies when 'kind' is set to 'average'rzFThe 'recursion' method can only be applied when sample_weight is None.)GradientBoostingClassifierGradientBoostingRegressorHistGradientBoostingClassifierHistGradientBoostingRegressorrr rz[Only the following estimators support the 'recursion' method: {}. Try using method='brute'.r=rjzRWith the 'recursion' method, the response_method must be 'decision_function'. Got .F) accept_sliceintzall features must be in [0, r"]C)r1orderzPassing an empty list (`[]`) to `categorical_features` is not supported. Use `None` instead to indicate that there are no categorical features.bzeWhen `categorical_features` is a boolean array-like, the array should be of shape (n_features,). Got z elements while `X` contains z features.)rvOU)rzXExpected `categorical_features` to be an array-like of boolean, integer, or string. Got z instead.r@iuz The column a contains integer data. Partial dependence plots are not supported for integer data: this can lead to implicit rounding with NumPy arrays or even errors with newer pandas versions. Please convert numerical features to floating point dtypes ahead of time to avoid problems.r^) grid_valuesr).rrrrFr,classes_r4ndarrayhasattrrissparserr3r initr r rformatrIrrr2lessrMr5rintpravelr rEsizer1rr r-rziprrJgetr\r{r`rer)rrQrcrrrrrlrRrTrUrrsupported_classes_recursionfeatures_indices n_featuresrSidxcatcategorical_features_idx feature_idxrWrXX_subsetindexcustom_values_for_X_subsetrbr6rdrsval pdp_resultss r&rr]sNI ) $ $ Y(?(?PQQYJy/A/A!/Dbjj$Q$QNOO A{ # #vq'9'9 [ GI?f#<    y [ U  !: T    $F  #7 8 8Y^^=S F   %'<>S T  !FF  $(%%    + '88>II9:9  f $1O 1 1,,;+ 8%8EA 66"''(A& ' ';AGGAJN;K1MN NzzA(s eg):MJ#3'7#88!zz*>?  $ $ )(  % % * *c 1#((J6 G+0011N!l*. DTTCSC237CSNTN ! ' ' , , ?0(/C#3mD/ %( .s*T'T,(T1' T68T6T< U r+)6__doc__collections.abcrnumpyr4scipyrscipy.stats.mstatsr sklearn.baserrsklearn.ensemblersklearn.ensemble._gbr :sklearn.ensemble._hist_gradient_boosting.gradient_boostingr sklearn.inspection._pd_utilsr r sklearn.treer sklearn.utilsrrrsklearn.utils._indexingrrr$sklearn.utils._optional_dependenciesrsklearn.utils._param_validationrrrrrsklearn.utils._responsersklearn.utils.extmathrsklearn.utils.validationrr__all__r\rer{r-tupledictrr#r9r&rs\H %)425R.<< J9+J  u%p7 v<@}-@ y) * / 0 23 4 O ,!8S1&-!-t 4&-&'UVWw$Xq$vFG<=>=>?!$#''4  S+*Sr9