-iSSKrSSKJr SSKJr SSKrSSKJr SSK J r SSK J r SSK JrJrJrJr SS KJr SS KJr SS KJr SS KJrJr S SKJr S SKJrJr "SS5r g)N)chain)ceil)sparse) mquantiles) is_regressor)Bunch_safe_indexing check_arraycheck_random_state)_unique)check_matplotlib_support)_validate_style_kwargs)Paralleldelayed)partial_dependence)_check_feature_names_get_feature_indexc\rSrSrSrSSSSS.Sjr\SSSSSS S S SSSS SSSSSSS SSS.Sj5rSrSr Sr Sr Sr SS SSSSSSSS S. Sjr Srg)PartialDependenceDisplayaCPartial Dependence Plot (PDP) and Individual Conditional Expectation (ICE). It is recommended to use :func:`~sklearn.inspection.PartialDependenceDisplay.from_estimator` to create a :class:`~sklearn.inspection.PartialDependenceDisplay`. All parameters are stored as attributes. For general information regarding `scikit-learn` visualization tools, see the :ref:`Visualization Guide `. For guidance on interpreting these plots, refer to the :ref:`Inspection Guide `. For an example on how to use this class, see the following example: :ref:`sphx_glr_auto_examples_miscellaneous_plot_partial_dependence_visualization_api.py`. .. versionadded:: 0.22 Parameters ---------- pd_results : list of Bunch Results of :func:`~sklearn.inspection.partial_dependence` for ``features``. features : list of (int,) or list of (int, int) Indices of features for a given plot. A tuple of one integer will plot a partial dependence curve of one feature. A tuple of two integers will plot a two-way partial dependence curve as a contour plot. feature_names : list of str Feature names corresponding to the indices in ``features``. target_idx : int - In a multiclass setting, specifies the class for which the PDPs should be computed. Note that for binary classification, the positive class (index 1) is always used. - In a multioutput setting, specifies the task for which the PDPs should be computed. Ignored in binary classification or classical regression settings. deciles : dict Deciles for feature indices in ``features``. kind : {'average', 'individual', 'both'} or list of such str, default='average' Whether to plot the partial dependence averaged across all the samples in the dataset or one line per sample or both. - ``kind='average'`` results in the traditional PD plot; - ``kind='individual'`` results in the ICE plot; - ``kind='both'`` results in plotting both the ICE and PD on the same plot. A list of such strings can be provided to specify `kind` on a per-plot basis. The length of the list should be the same as the number of interaction requested in `features`. .. note:: ICE ('individual' or 'both') is not a valid option for 2-ways interactions plot. As a result, an error will be raised. 2-ways interaction plots should always be configured to use the 'average' kind instead. .. note:: 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 Add `kind` parameter with `'average'`, `'individual'`, and `'both'` options. .. versionadded:: 1.1 Add the possibility to pass a list of string specifying `kind` for each plot. subsample : float, int or None, default=1000 Sampling for ICE curves when `kind` is 'individual' or 'both'. If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to be used to plot ICE curves. If int, represents the maximum absolute number of samples to use. Note that the full dataset is still used to calculate partial dependence when `kind='both'`. .. versionadded:: 0.24 random_state : int, RandomState instance or None, default=None Controls the randomness of the selected samples when subsamples is not `None`. See :term:`Glossary ` for details. .. versionadded:: 0.24 is_categorical : list of (bool,) or list of (bool, bool), default=None Whether each target feature in `features` is categorical or not. The list should be same size as `features`. If `None`, all features are assumed to be continuous. .. versionadded:: 1.2 Attributes ---------- bounding_ax_ : matplotlib Axes or None If `ax` is an axes or None, the `bounding_ax_` is the axes where the grid of partial dependence plots are drawn. If `ax` is a list of axes or a numpy array of axes, `bounding_ax_` is None. axes_ : ndarray of matplotlib Axes If `ax` is an axes or None, `axes_[i, j]` is the axes on the i-th row and j-th column. If `ax` is a list of axes, `axes_[i]` is the i-th item in `ax`. Elements that are None correspond to a nonexisting axes in that position. lines_ : ndarray of matplotlib Artists If `ax` is an axes or None, `lines_[i, j]` is the partial dependence curve on the i-th row and j-th column. If `ax` is a list of axes, `lines_[i]` is the partial dependence curve corresponding to the i-th item in `ax`. Elements that are None correspond to a nonexisting axes or an axes that does not include a line plot. deciles_vlines_ : ndarray of matplotlib LineCollection If `ax` is an axes or None, `vlines_[i, j]` is the line collection representing the x axis deciles of the i-th row and j-th column. If `ax` is a list of axes, `vlines_[i]` corresponds to the i-th item in `ax`. Elements that are None correspond to a nonexisting axes or an axes that does not include a PDP plot. .. versionadded:: 0.23 deciles_hlines_ : ndarray of matplotlib LineCollection If `ax` is an axes or None, `vlines_[i, j]` is the line collection representing the y axis deciles of the i-th row and j-th column. If `ax` is a list of axes, `vlines_[i]` corresponds to the i-th item in `ax`. Elements that are None correspond to a nonexisting axes or an axes that does not include a 2-way plot. .. versionadded:: 0.23 contours_ : ndarray of matplotlib Artists If `ax` is an axes or None, `contours_[i, j]` is the partial dependence plot on the i-th row and j-th column. If `ax` is a list of axes, `contours_[i]` is the partial dependence plot corresponding to the i-th item in `ax`. Elements that are None correspond to a nonexisting axes or an axes that does not include a contour plot. bars_ : ndarray of matplotlib Artists If `ax` is an axes or None, `bars_[i, j]` is the partial dependence bar plot on the i-th row and j-th column (for a categorical feature). If `ax` is a list of axes, `bars_[i]` is the partial dependence bar plot corresponding to the i-th item in `ax`. Elements that are None correspond to a nonexisting axes or an axes that does not include a bar plot. .. versionadded:: 1.2 heatmaps_ : ndarray of matplotlib Artists If `ax` is an axes or None, `heatmaps_[i, j]` is the partial dependence heatmap on the i-th row and j-th column (for a pair of categorical features) . If `ax` is a list of axes, `heatmaps_[i]` is the partial dependence heatmap corresponding to the i-th item in `ax`. Elements that are None correspond to a nonexisting axes or an axes that does not include a heatmap. .. versionadded:: 1.2 figure_ : matplotlib Figure Figure containing partial dependence plots. See Also -------- partial_dependence : Compute Partial Dependence values. PartialDependenceDisplay.from_estimator : Plot Partial Dependence. Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from sklearn.datasets import make_friedman1 >>> from sklearn.ensemble import GradientBoostingRegressor >>> from sklearn.inspection import PartialDependenceDisplay >>> from sklearn.inspection import partial_dependence >>> X, y = make_friedman1() >>> clf = GradientBoostingRegressor(n_estimators=10).fit(X, y) >>> features, feature_names = [(0,)], [f"Features #{i}" for i in range(X.shape[1])] >>> deciles = {0: np.linspace(0, 1, num=5)} >>> pd_results = partial_dependence( ... clf, X, features=0, kind="average", grid_resolution=5) >>> display = PartialDependenceDisplay( ... [pd_results], features=features, feature_names=feature_names, ... target_idx=0, deciles=deciles ... ) >>> display.plot(pdp_lim={1: (-1.38, 0.66)}) <...> >>> plt.show() averageiN)kind subsample random_stateis_categoricalcpXlX lX0lX@lXPlX`lXplXlXlgN pd_resultsfeatures feature_names target_idxdecilesrrrr) selfr!r"r#r$r%rrrrs ^/var/www/html/venv/lib/python3.13/site-packages/sklearn/inspection/_plot/partial_dependence.py__init__!PartialDependenceDisplay.__init__s4% *$  "(,autord)皙?gffffff?rF) sample_weightcategorical_featuresr#targetresponse_methodn_colsgrid_resolution percentiles custom_valuesmethodn_jobsverboseline_kw ice_lines_kw pd_line_kw contour_kwaxrcenteredrrc^^^^^^^ ^ ^ ^ [URS35 SSKJn [ TS5(a[ R "TR5S:aUc [S5e[ R"TRU5nSUs=::a[TR5:aO OTRUU:wa[SRU55eOSn[ TS5(d*[R"T5(d[TS [S 9mTR S n[#TT5m[%U[&5(aU/[U5-OUn[U5[U5:wa$[S [U5S [U5S35e//nn[)UU5Hunn [%U [*R,[&45(aU 4n [/U4SjU 55n S [ R "U 5s=::aS::d O [S5eUR3US:g=(a [ R "U 5S :5 UR3U 5 M [5U5(a>[)UU5V"Vs/sHun"nU"(aSOUPM nn"n[SU<SU<S35eUnTc%UV s/sHn [U 5S :XaSOSPM n#n GO[ R6"T5mTR8R:S:XaRTR U:wa[STR SUS35eUV s/sHn [/U4SjU 55PM n#n OTR8R:S;aLTV$s/sH n$[=U$TS9PM n%n$UV V&s/sH"n [/U V&s/sHn&U&U%;PM sn&5PM$ n#n n&O[STR8S35eU#H6n'[ R "U'5S:XdMU'SU'S :wdM-[S 5e [?[)UU#5V V'V(s/sH$un n'U Hn([5U'5(dMU(PM M& sn(n'n 5n)U)(aO[AU)V&s/sH n&[[C[ETU&S S!955PM" sn&5n*T U*:a[S"U*S#T S35e[)U#U5H)un+n[5U+5(dMUS:wdM [S$5e Ub{[%UURF5(d`[ R6"U[S%9n,U,R [U5:wa.[S&R[U5U,R 55e[HRJ"U5H6n-U-[T5:dM[S'R[T5U-55e [%U[*R,5(aUS::a[S(US)35eO:[%U[*RL5(aUS::dUS :a[S*US+35e[OXS,9"UUU UUU U U UU4 S-j[)UU555n.U.Sn/USS:XaU/RPR SOU/RRR Sn0[UT5(a?U0S :a9Uc [S.5eSUs=::aU0::dO [S/RU55eUn0n1[)UU#5H[un n'[)U U'5HEun(n$U$(aMU(U1;dM[ETU(S S!9n2[WU2[ RX"S0S1S05S29U1U('MG M] U"U.UTUU1UUUU#S39 n3U3R[UU UUUUUS49$![0an![S5U!eSn!A!ff=fs snn"fs sn fs sn fs sn$fs sn&fs sn&n fs sn(n'n fs sn&f)5a-Partial dependence (PD) and individual conditional expectation (ICE) plots. Partial dependence plots, individual conditional expectation plots, or an overlay of both can be plotted by setting the `kind` parameter. This method generates one plot for each entry in `features`. The plots are arranged in a grid with `n_cols` columns. For one-way partial dependence plots, the deciles of the feature values are shown on the x-axis. For two-way plots, the deciles are shown on both axes and PDPs are contour plots. For general information regarding `scikit-learn` visualization tools, see the :ref:`Visualization Guide `. For guidance on interpreting these plots, refer to the :ref:`Inspection Guide `. For an example on how to use this class method, see :ref:`sphx_glr_auto_examples_inspection_plot_partial_dependence.py`. .. note:: :func:`PartialDependenceDisplay.from_estimator` does not support using the same axes with multiple calls. To plot the partial dependence for multiple estimators, please pass the axes created by the first call to the second call:: >>> from sklearn.inspection import PartialDependenceDisplay >>> from sklearn.datasets import make_friedman1 >>> from sklearn.linear_model import LinearRegression >>> from sklearn.ensemble import RandomForestRegressor >>> X, y = make_friedman1() >>> est1 = LinearRegression().fit(X, y) >>> est2 = RandomForestRegressor().fit(X, y) >>> disp1 = PartialDependenceDisplay.from_estimator(est1, X, ... [1, 2]) >>> disp2 = PartialDependenceDisplay.from_estimator(est2, X, [1, 2], ... ax=disp1.axes_) .. 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`. .. versionadded:: 1.0 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, 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 : list of {int, str, pair of int, pair of str} The target features for which to create the PDPs. If `features[i]` is an integer or a string, a one-way PDP is created; if `features[i]` is a tuple, a two-way PDP is created (only supported with `kind='average'`). Each tuple must be of size 2. If any entry is a string, then it must be in ``feature_names``. 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. target : int, default=None - In a multiclass setting, specifies the class for which the PDPs should be computed. Note that for binary classification, the positive class (index 1) is always used. - In a multioutput setting, specifies the task for which the PDPs should be computed. Ignored in binary classification or classical regression settings. 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`. n_cols : int, default=3 The maximum number of columns in the grid plot. Only active when `ax` is a single axis or `None`. grid_resolution : int, default=100 The number of equally spaced points on the axes of the plots, for each target feature. This parameter is overridden by `custom_values` if that parameter is set. percentiles : tuple of float, default=(0.05, 0.95) The lower and upper percentile used to create the extreme values for the PDP axes. Must be in [0, 1]. 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`. .. versionadded:: 1.7 method : str, 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` but 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 ICEs 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. n_jobs : int, default=None The number of CPUs to use to compute the partial dependences. Computation is parallelized over features specified by the `features` parameter. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. verbose : int, default=0 Verbose output during PD computations. line_kw : dict, default=None Dict with keywords passed to the ``matplotlib.pyplot.plot`` call. For one-way partial dependence plots. It can be used to define common properties for both `ice_lines_kw` and `pdp_line_kw`. ice_lines_kw : dict, default=None Dictionary with keywords passed to the `matplotlib.pyplot.plot` call. For ICE lines in the one-way partial dependence plots. The key value pairs defined in `ice_lines_kw` takes priority over `line_kw`. pd_line_kw : dict, default=None Dictionary with keywords passed to the `matplotlib.pyplot.plot` call. For partial dependence in one-way partial dependence plots. The key value pairs defined in `pd_line_kw` takes priority over `line_kw`. contour_kw : dict, default=None Dict with keywords passed to the ``matplotlib.pyplot.contourf`` call. For two-way partial dependence plots. ax : Matplotlib axes or array-like of Matplotlib axes, default=None - If a single axis is passed in, it is treated as a bounding axes and a grid of partial dependence plots will be drawn within these bounds. The `n_cols` parameter controls the number of columns in the grid. - If an array-like of axes are passed in, the partial dependence plots will be drawn directly into these axes. - If `None`, a figure and a bounding axes is created and treated as the single axes case. kind : {'average', 'individual', 'both'}, default='average' Whether to plot the partial dependence averaged across all the samples in the dataset or one line per sample or both. - ``kind='average'`` results in the traditional PD plot; - ``kind='individual'`` results in the ICE plot. 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'`. centered : bool, default=False If `True`, the ICE and PD lines will start at the origin of the y-axis. By default, no centering is done. .. versionadded:: 1.1 subsample : float, int or None, default=1000 Sampling for ICE curves when `kind` is 'individual' or 'both'. If `float`, should be between 0.0 and 1.0 and represent the proportion of the dataset to be used to plot ICE curves. If `int`, represents the absolute number samples to use. Note that the full dataset is still used to calculate averaged partial dependence when `kind='both'`. random_state : int, RandomState instance or None, default=None Controls the randomness of the selected samples when subsamples is not `None` and `kind` is either `'both'` or `'individual'`. See :term:`Glossary ` for details. Returns ------- display : :class:`~sklearn.inspection.PartialDependenceDisplay` See Also -------- partial_dependence : Compute Partial Dependence values. Examples -------- >>> import matplotlib.pyplot as plt >>> from sklearn.datasets import make_friedman1 >>> from sklearn.ensemble import GradientBoostingRegressor >>> from sklearn.inspection import PartialDependenceDisplay >>> X, y = make_friedman1() >>> clf = GradientBoostingRegressor(n_estimators=10).fit(X, y) >>> PartialDependenceDisplay.from_estimator(clf, X, [0, (0, 1)]) <...> >>> plt.show() z.from_estimatorrNclasses_rz(target must be specified for multi-classz"target not in est.classes_, got {} __array__z allow-nan)ensure_all_finitedtypepWhen `kind` is provided as a list of strings, it should contain as many elements as `features`. `kind` contains $ element(s) and `features` contains element(s).c38># UHn[UTS9v M g7f)r#N)r).0fxr#s r' :PartialDependenceDisplay.from_estimator..HsRUB&rGRUszYEach entry in features must be either an int, a string, or an iterable of size at most 2.rzICE plot cannot be rendered for 2-way feature interactions. 2-way feature interactions mandates PD plots using the 'average' kind: features=z" should be configured to use kind=z explicitly.FFFbzeWhen `categorical_features` is a boolean array-like, the array should be of shape (n_features,). Got z elements while `X` contains z features.c3.># UH nTUv M g7fr)rJrKr/s r'rLrM~sASr.r2Ss)iOUrIzXExpected `categorical_features` to be an array-like of boolean, integer, or string. Got z instead.zdTwo-way partial dependence plots are not supported for pairs of continuous and categorical features.)axiszThe resolution of the computed grid is less than the minimum number of categories in the targeted categorical features. Expect the `grid_resolution` to be greater than z. Got zJIt is not possible to display individual effects for categorical features.rC#Expected ax to have {} axes, got {}zLAll entries of features must be less than len(feature_names) = {0}, got {1}.zWhen an integer, subsample=z should be positive.z!When a floating-point, subsample=z should be in the (0, 1) range.)r7r8c3d> # UH%up[[5"TTUT TTT T TT UTS9 v M' g7f)) r.r#r/r1r6r3r4rr5N)rr) rJ kind_plotfxsXr/r5 estimatorr#r3r6r4r1r.s r'rLrMsM> #7  & '++%9 / /'+ #7s-0z4target must be specified for multi-output regressorsz'target must be in [0, n_tasks], got {}.g??)probr )r=r2r9r:r;r<r>).r__name__matplotlib.pyplotpyplothasattrnpsizer@ ValueError searchsortedlenformatrissparser objectshaper isinstancestrzipnumbersIntegraltuple TypeErrorappendanyasarrayrCrrsetminr r Axesr from_iterableRealrr individualrrarangeplot)4clsr]r\r"r.r/r#r0r1r2r3r4r5r6r7r8r9r:r;r<r=rr>rrpltr$ n_featureskind_ tmp_featuresice_for_two_way_pdrZr[eforcing_averagercatcategorical_features_idxidxcatsrKcategorical_features_targeted min_n_catsis_cataxesrSr! pd_resultn_tasksr%X_coldisplays4 `` ``` ` ```` r'from_estimator'PartialDependenceDisplay.from_estimatorsP !CLL>!AB' 9j ) )bggi6H6H.IA.M~ !KLL););VDJ*>s9+=+='>>%%j1V; !E!L!LV!TUU< J;''6??1+=+=AFKAWWQZ ,Q > *4T3*?*?X&T u:X &CCFu:,O669(m_LR ,.r( !%2NIs# 0 0#677f RU )) B  % %i9&<&QPQAQ R    $-30 ! " " 366H%2P2P.OY- );2P %<(y .    'IQIQ#CHM~= N $&::.B#C #))..#5',, :$K/4455R%,j2NV"MUcEASAAX"&++00OC 4,3's-H3), ("'cJcs3"::cJK'" !00D0J0J/K9V '774=A%47d1g+=$C'-0&)>%B%B T!4y!%B- )- $A#@CGN1c$BCD#@ #Z/$U&,f_,=YH&)%?! v;;9 #9$1&@ >*R":":::b/DyyCM) 9@@H tyy $$X.AC && 99?M@RTU9V/ i!1!1 2 2A~ 1) > #&eX"6>  .qM Qx9$    # #A &%%++A.   " "w{~ !WXX)') =DDVL JX~6ICsD>Csr0*1bq9E",U3S9Q"RGBK*7 !'!%)  ||%!!  E  B ( " , K"(sZ]8^:^;^!;^&^0%^+4 ^0-^6  ^6 1'^=8 ^ ^^+^0c[UR[R5(aURU:a UR$U$[UR[R5(a[ XR-5$U$)z,Compute the number of samples as an integer.)rmrrprqr{r)r& n_sampless r'_get_sample_count*PartialDependenceDisplay._get_sample_countsb dnng&6&6 7 7~~ )~~%   5 5 NN23 3r*cd[UR5nURURSUSS9n XSS24n [ U 5Hfup[ R "XV-U -URR5n UR"X,R540UD6SURU 'Mh g)a Plot the ICE lines. Parameters ---------- preds : ndarray of shape (n_instances, n_grid_points) The predictions computed for all points of `feature_values` for a given feature for all samples in `X`. feature_values : ndarray of shape (n_grid_points,) The feature values for which the predictions have been computed. n_ice_to_plot : int The number of ICE lines to plot. ax : Matplotlib axes The axis on which to plot the ICE lines. pd_plot_idx : int The sequential index of the plot. It will be unraveled to find the matching 2D position in the grid layout. n_total_lines_by_plot : int The total number of lines expected to be plot on the axis. individual_line_kw : dict Dict with keywords passed when plotting the ICE lines. rF)replaceN) r rchoicerl enumeraterd unravel_indexlines_r~ravel)r&predsfeature_values n_ice_to_plotr= pd_plot_idxn_total_lines_by_plotindividual_line_kwrng ice_lines_idxice_lines_subsampledice_idxiceline_idxs r'_plot_ice_lines(PartialDependenceDisplay._plot_ice_lines!s@!!2!23 KKN # %A%56%&:;LG''3g=t{{?P?PH%'GG %/A%%DKK !  &&{JJ4D4DEG"$&&"Mf"Ma"PDJJw  NNbN 1'' [[5F5FGH$&GG%% %DKK !r*c 6SSKJn US;a#URX RUUUU U U 5 US;aAUS:XaU nOX-U-nUR X0RR 5UUUU U U5 UR URUR5n[R"XRR5nURRUSS5b0URURUSSSUSS 9URU'[!S UR#555n[%S UR#555nUR'UU/5 UR)5(d!UR+UR,US5 UbX-S:Xa'UR/5(dUR1S 5 OUR3/5 U RS S5(a US:waU (dUR55 gggg)a Plot 1-way partial dependence: ICE and PDP. Parameters ---------- kind : str The kind of partial plot to draw. preds : ndarray of shape (n_instances, n_grid_points) or None The predictions computed for all points of `feature_values` for a given feature for all samples in `X`. avg_preds : ndarray of shape (n_grid_points,) The average predictions for all points of `feature_values` for a given feature for all samples in `X`. feature_values : ndarray of shape (n_grid_points,) The feature values for which the predictions have been computed. feature_idx : int The index corresponding to the target feature. n_ice_lines : int The number of ICE lines to plot. ax : Matplotlib axes The axis on which to plot the ICE and PDP lines. n_cols : int or None The number of column in the axis. pd_plot_idx : int The sequential index of the plot. It will be unraveled to find the matching 2D position in the grid layout. n_lines : int The total number of lines expected to be plot on the axis. ice_lines_kw : dict Dict with keywords passed when plotting the ICE lines. pd_line_kw : dict Dict with keywords passed when plotting the PD plot. categorical : bool Whether feature is categorical. bar_kw: dict Dict with keywords passed when plotting the PD bars (categorical). pdp_lim : dict Global min and max average predictions, such that all plots will have the same scale and y limits. `pdp_lim[1]` is the global min and max for single partial dependence curves. r transformsr|bothrrrNr-k transformcolorc3*# UH oSv M g7f)rNrRrJvals r'rLLPartialDependenceDisplay._plot_one_way_partial_dependence..9(8!f(8c3*# UH oSv M g7f)rDNrRrs r'rLrrrzPartial dependencelabelr|) matplotlibrrr$rrblended_transform_factory transData transAxesrdrdeciles_vlines_rlr%getvlinesrxvaluesmaxset_ylim get_xlabel set_xlabelr# get_ylabel set_ylabelset_yticklabelslegend)r&rrrr feature_idx n_ice_linesr=r2rn_linesr:r;rrpdp_limrrtrans vlines_idxmin_valmax_vals r' _plot_one_way_partial_dependence9PartialDependenceDisplay._plot_one_way_partial_dependence}sv * ) )  oo&  & &y ) )3kA  ) )//*002 44R\\2<<P%%k3G3G3M3MN <<  KND 1 =/1yy [^, 090D  ,9(8999(899 Wg&'}} MM$,,[^< = >[1Q6==?? 23   r " >>'4 ( (T\-A+ IIKKV-A (r*c U(Ga SSKJn [SSS9n 0U EU En XRn UR"U 40U D6nSnUR S5UR S5nn[ R"U [S9nU R5U R5-S- n[U R5Hnn[ R"UU R5unnU UU4U:aUOUnS n[U UU4U5n[S S US 9nUR "UUU40UD6UUU4'Mp UR"nUR%XS 9 UR'[ R("[+US 55[ R("[+US55US USUR,US UR,USS9 U R/UR15SS9 [ R"XPR2R5nXR2U'gSSKJn [ R8"USUS 5unnXRR:nUR=UUUUSSS9n [ R"XPR>R5n!UR@"UUU4UUSUSS.UD6UR>U!'URCU SSSSS9 UREURFURH5n"URK5URM5n$n#[ R"XPRNR5n%URQURRUSSSU"SS9URNU%'[ R"XPRTR5n&URWURRUS SSU"SS9URTU&'URYU#5 UR[U$5 UR]5(d!UR_UR,US5 URaUR,US 5 g)aPlot 2-way partial dependence. Parameters ---------- avg_preds : ndarray of shape (n_instances, n_grid_points, n_grid_points) The average predictions for all points of `feature_values[0]` and `feature_values[1]` for some given features for all samples in `X`. feature_values : seq of 1d array A sequence of array of the feature values for which the predictions have been computed. feature_idx : tuple of int The indices of the target features ax : Matplotlib axes The axis on which to plot the ICE and PDP lines. pd_plot_idx : int The sequential index of the plot. It will be unraveled to find the matching 2D position in the grid layout. Z_level : ndarray of shape (8, 8) The Z-level used to encode the average predictions. contour_kw : dict Dict with keywords passed when plotting the contours. categorical : bool Whether features are categorical. heatmap_kw: dict Dict with keywords passed when plotting the PD heatmap (categorical). rNnearestviridis) interpolationcmapr^rWg@z.2fcenter)havar)r=rD)xticksyticks xticklabels yticklabelsxlabelylabelvertical)rr?r)levels linewidthscolors)rvmaxvminz%2.2f T)fmtrfontsizeinliner-r)1rarbdictr$imshowrrd empty_likerkrrxrangererrlritextfigurecolorbarrwr}rhr#setpget_xticklabels heatmaps_rrmeshgridTcontour contours_contourfclabelrrrget_xlimget_ylimrrr%deciles_hlines_hlinesset_xlimrrrr)'r&rrrr=rZ_levelr<r heatmap_kwr default_im_kwim_kwdataimrcmap_mincmap_maxthresh flat_indexrowcolr values_format text_data text_kwargsfig heatmap_idxrXXYYZCS contour_idxrxlimylimr hlines_idxs' r' _plot_two_way_partial_dependence9PartialDependenceDisplay._plot_two_way_partial_dependencesP  + yyIM3}3 3E__-D4)5)BD!#RWWS\hH==V4Dhhj488:-4F#DII. ++J CS$(cNV$; % "4S>=A "h85I !#c9!L !LS#X/))C LLL # FFyy^A%6!78yy^A%6!78*1-*1-))+a.9))+a.9   HHR'')JH ?**;8L8LMK*,NN; ' -[[!2N14EFFB//*,,ABAg#cRB**;8L8LMK*,+++R[QZ ++DNN; ' IIbgcBtI L88r||TE $D))+7K7K7Q7QRJ/1yy [^, 090D  ,))+7K7K7Q7QRJ/1yy [^, 090D  , KK  KK ==?? d00Q@A MM$,,[^< =r*) r=r2r9r:r;r<rrrr>c [S5 SSKJn SSKJn [ UR [5(a$UR /[UR5-n O UR n URc.URVs/sHn[U5S:XaSOSPM nnO URn[U 5[UR5:wa.[S[U 5S [UR5S 35e1S kn[U Vs/sHnUU;PM sn5(a[S U<S UR <35eU (d URnO/n[XR5HunnSUS0nUS;a)URnUUUR SS2SS4- nUUS'US;a&UR"nUUUR SS4- nUUS'UR%['S+0UD65 M U c0n [U U5HunnUSnUS:Xa UR"O URnUUR R)5nUUR R+5nUU- nUSU--nUSU-- n[U5nU R-UUU45unn[)UU5n[+UU5nUU4U U'M Uc0nUc0nUc0nUc0nUc0nUcU R/5un nUc0nSS0n![1U!U5n[UR5n"U Vs/sHnUS:HPM n#n[3U#5(aSn$Sn%OgU#R5S5n&UR7[UU&RS55n$[U Vs/sHnUS:HPM sn5(aU$S-n%OU$n%[ XR85(GaUR:(d [S5eUR=5 XlUR@Ul![)UU"5n[E[FRH"U"[KU5- 55n'[FRL"U'U4[NS9Ul([3U#5(a![FRL"U'U4[NS9Ul)O![FRL"U'UU%4[NS9Ul)[FRL"U'U4[NS9Ul*[FRL"U'U4[NS9Ul+[FRL"U'U4[NS9Ul,URPR[5n(U "U'X!R]5S9n)[[_U"5U)5H$un*n+URBRaU+5U(U*'M& GOT[FRb"U[NS9nURdU":wa%[SRgU"URd55eURhS:XaURjSnOSnSUlUR[5SR@Ul!Xl([3U#5(a[FRl"U[NS9Ul)O,[FRL"URjU%4-[NS9Ul)[FRl"U[NS9Ul*[FRl"U[NS9Ul+[FRl"U[NS9Ul,SU ;a[FRn"U SSS06n,[FRl"URP[NS9Ul8[FRl"URP[NS9Ul9[u[URPR[5URUUU 55GHIun-un.n/n0nnSnSnUSn1US:Xa URnO+US:Xa UR"nOUR"nURn[U15S:XaSUS:XaSOSS .n2US:XaS!S"S#.n30n4OUS:Xa S!S"S$S%.n3S&S'S(.n4O0n30n40U2EU3En30U2EU4En4[1U2U5n[1[1U3U5U5nUS) [1[1U4U5U5nS*S0n5[1U5U5n0n6[1U6U5nURwUUUU1SU/U$U.UU-U%UUU0SUU 5 GM!URyUU1U/U.U-W,UU0S=(a U0SU5 GML U$s snfs snfs snfs snf),a Plot partial dependence plots. Parameters ---------- ax : Matplotlib axes or array-like of Matplotlib axes, default=None - If a single axis is passed in, it is treated as a bounding axes and a grid of partial dependence plots will be drawn within these bounds. The `n_cols` parameter controls the number of columns in the grid. - If an array-like of axes are passed in, the partial dependence plots will be drawn directly into these axes. - If `None`, a figure and a bounding axes is created and treated as the single axes case. n_cols : int, default=3 The maximum number of columns in the grid plot. Only active when `ax` is a single axes or `None`. line_kw : dict, default=None Dict with keywords passed to the `matplotlib.pyplot.plot` call. For one-way partial dependence plots. ice_lines_kw : dict, default=None Dictionary with keywords passed to the `matplotlib.pyplot.plot` call. For ICE lines in the one-way partial dependence plots. The key value pairs defined in `ice_lines_kw` takes priority over `line_kw`. .. versionadded:: 1.0 pd_line_kw : dict, default=None Dictionary with keywords passed to the `matplotlib.pyplot.plot` call. For partial dependence in one-way partial dependence plots. The key value pairs defined in `pd_line_kw` takes priority over `line_kw`. .. versionadded:: 1.0 contour_kw : dict, default=None Dict with keywords passed to the `matplotlib.pyplot.contourf` call for two-way partial dependence plots. bar_kw : dict, default=None Dict with keywords passed to the `matplotlib.pyplot.bar` call for one-way categorical partial dependence plots. .. versionadded:: 1.2 heatmap_kw : dict, default=None Dict with keywords passed to the `matplotlib.pyplot.imshow` call for two-way categorical partial dependence plots. .. versionadded:: 1.2 pdp_lim : dict, default=None Global min and max average predictions, such that all plots will have the same scale and y limits. `pdp_lim[1]` is the global min and max for single partial dependence curves. `pdp_lim[2]` is the global min and max for two-way partial dependence curves. If `None` (default), the limit will be inferred from the global minimum and maximum of all predictions. .. versionadded:: 1.1 centered : bool, default=False If `True`, the ICE and PD lines will start at the origin of the y-axis. By default, no centering is done. .. versionadded:: 1.1 Returns ------- display : :class:`~sklearn.inspection.PartialDependenceDisplay` Returns a :class:`~sklearn.inspection.PartialDependenceDisplay` object that contains the partial dependence plots. plot_partial_dependencerN)GridSpecFromSubplotSpecrDrNrOrErFrG>rrr|z*Values provided to `kind` must be one of: z+ or a list of such values. Currently, kind= grid_valuesrr|rrr-alphag?FrzUThe ax was already used in another plot function, please set ax=display.axes_ insteadrW) subplot_specrXrnumC0)rrg333333?r)r6 linewidthztab:blue)r6r;rz tab:orangez--)r linestylerrrR)=rrarbmatplotlib.gridspecr4rmrrnrhr"rrfrur!ror|r$rrtr rxrrsubplotsrallindexrryaxison set_axis_off bounding_ax_rfigure_intrdrfloatemptyrkaxes_rrrr rget_subplotspecr add_subplotrvrerindimrlrlinspacerrrrr0)7r&r=r2r9r:r;r<rrrr>rr4rrKr valid_kindsr pd_results_rZrcurrent_resultsrrpdprmin_pdmax_pdspann_fx old_min_pd old_max_pd_default_contour_kwsris_average_plotrr ice_plot_idxn_rows axes_ravelgsrSspecrraxirrrdefault_line_kwsdefault_ice_lines_kwsdefault_pd_lines_kwsdefault_bar_kwsdefault_heatmap_kws7 r'r~PartialDependenceDisplay.plotrst !!:;'? dii % %II;T]]!33D99D    &GK}}GTCGqLn<} N"00N t9DMM* *Kt9+At}}%&l4 8 d3d$d3 4 4<[OL448II=B  //KK(+D//(B$ 9#0)M2J"K 66%00E!E$//1a*E$FFE49OL1 33 ) 1 1I )Idooq$6N,O OI1:OI.""5#;?#;<)C ?G"%dK"8 3]+'0I'= 3>>t/335t/335$+%$+%6{)0TFF;K)L& JVZ0VZ0!' 0 !#9$ ?G  L  J >F  J :LLNEAr  J&o+,?L ' CGH4i9 14H   KG+007L00K -88;<K>II'>??%/% b(( # #99  OO  " 99DL,FeFm!;<=F66"2&ADJ?## hh'7vF  hh'@O XXvv&6fEDN66"2&ADJXXvv&6fEDN))+J(-?-?-ABuZ0"54 $ 8 8 > 1 6Bf-Bww*$ 9@@RWWUww!|! $D 88:a=//DLJ?## mmBf=  hhrxx7*'"a'"*3v*=Y4$  ,69,L)+-(&("%%(!+-) ".%),( -/)+-((U+;(U?T(U%'S*:'S>R'S$01A7K5*+@'JL  !)3*+?I: $+D//H%'"34F S 55"1% F$55"F%s1v gK ~ C4FI?sc cc c)rHrrCrr%rrr#r"rDr rrrr!rrr$)r` __module__ __qualname____firstlineno____doc__r( classmethodrrrrrr0r~__static_attributes__rRr*r'rrsD\-.!   5[ [ z/b)Vsj~>F eer*r)!rp itertoolsrmathrnumpyrdscipyrscipy.stats.mstatsrbaserutilsr r r r utils._encoder utils._optional_dependenciesrutils._plottingrutils.parallelrrr _pd_utilsrrrrRr*r'rysF)  %D5/!@||r*