3;ji% ddlmZmZ ddZdS))_find_matching_floating_dtypeget_namespace_and_device2FNc & !t|\}}t|}|||}|||}|||}|j}|dkr|S|jdkr|d}|j|jkrD|jd|jdkr(||jddfj}|j} | dkr|d}|dd}  || d } |jd} || d  | | f}   | r0  || d }d| |< | jd !|jd}| |f||}t|D]\}}|d z !d z dk} | |dz |< !fdt%!jdD}| jddz }|d|} |jd| }| ||f}|r!||f z }||jk}|dzd|}| ||f}||||fdk}|D]M}!|||f}!|df|d}||kr||}| ||f||<N||||f|||f|||fzdz |d|f<|||f|d|f<| dkr|d}|dkr|dn|S)aCompute the weighted percentile. Implement an array API compatible (weighted version) of NumPy's 'inverted_cdf' method when `average=False` (default) and 'averaged_inverted_cdf' when `average=True`. For an array ordered by increasing values, when the percentile lies exactly on a data point: * 'inverted_cdf' takes the exact data point. * 'averaged_inverted_cdf' takes the average of the exact data point and the one above it (this means it gives the same result as `median` for unit weights). E.g., for the array [1, 2, 3, 4] the percentile rank at each data point would be [25, 50, 75, 100]. Percentile rank 50 lies on '2'. 'average_inverted_cdf' computes the average of '2' and '3', making it 'symmetrical' because if you reverse the array, rank 50 would fall on '3'. It also matches 'median'. On the other hand, 'inverted_cdf', which does not satisfy the symmetry property, would give '2'. When the requested percentile lies between two data points, both methods return the higher data point. E.g., for the array [1, 2, 3, 4, 5] the percentile rank at each data point would be [20, 40, 60, 80, 100]. Percentile rank 50, lies between '2' and '3'. Taking the higher data point is symmetrical because if you reverse the array, 50 would lie between '4' and '3'. Both methods match median in this case. If `array` is a 2D array, the `values` are selected along axis 0. `NaN` values are ignored by setting their weights to 0. If `array` is 2D, this is done in a column-isolated manner: a `NaN` in the second column, does not impact the percentile computed for the first column even if `sample_weight` is 1D. .. versionchanged:: 0.24 Accepts 2D `array`. .. versionchanged:: 1.7 Supports handling of `NaN` values. .. versionchanged:: 1.8 Supports `average`, which calculates percentile using the "averaged_inverted_cdf" method. Parameters ---------- array : 1D or 2D array Values to take the weighted percentile of. sample_weight: 1D or 2D array Weights for each value in `array`. Must be same shape as `array` or of shape `(array.shape[0],)`. percentile_rank: scalar or 1D array, default=50 The probability level(s) of the percentile(s) to compute, in percent. Must be between 0 and 100. If a 1D array, computes all percentiles (along each axis 0 if `array` is 2D). average : bool, default=False If `True`, uses the "averaged_inverted_cdf" quantile method, otherwise defaults to "inverted_cdf". "averaged_inverted_cdf" is symmetrical with unit `sample_weight`, such that the total of `sample_weight` below or equal to `_weighted_percentile(percentile_rank)` is the same as the total of `sample_weight` above or equal to `_weighted_percentile(100-percentile_rank)`. This symmetry is not guaranteed with non-unit weights. xp : array_namespace, default=None The standard-compatible namespace for `array`. Default: infer. Returns ------- percentile : scalar, 1D array, or 2D array Weighted percentile at the requested probability level(s). If `array` is 1D and `percentile_rank` is scalar, returns a scalar. If `array` is 2D and `percentile_rank` is scalar, returns a 1D array of shape `(array.shape[1],)` If `array` is 1D and `percentile_rank` is 1D, returns a 1D array of shape `(percentile_rank.shape[0],)` If `array` is 2D and `percentile_rank` is 1D, returns a 2D array of shape `(array.shape[1], percentile_rank.shape[0])` )xp)dtypedevicer)r )r F)axisstable)r )r .)r d).r cXg|]&}|df|'S).) searchsorted).0 feature_idxadjusted_percentile_rank weight_cdfrs M/root/voice-cloning/.venv/lib/python3.11/site-packages/sklearn/utils/stats.py z(_weighted_percentile..sN    {C/02J;2W   .right)side).r)r.)rrasarrayndimreshapeshapetileTargsorttake_along_axisarangeanyisnancumulative_sumempty enumerate nextafterstackrangeclipfinfoepsrwhere)"array sample_weightpercentile_rankaverager_r floating_dtypen_dimn_dim_percentile sorted_idxsorted_weights n_featureslargest_value_per_columnsorted_nan_mask n_percentilesresultp_idxp_rankmaskpercentile_indicesmax_idx col_indicespercentile_in_sortedfraction_aboveis_fraction_abovepercentile_plus_one_indicespercentile_plus_one_in_sortedzero_weight_colscol_idxcdf_val next_indexrrs" ` @@r_weighted_percentilerN sf-U33MB625R@@@N JJuN6J B BEJJ}N6JRRMjjvjVVO JE zz  zQ 5'** {m)))ek!n @STU@V.V.V  A/BCCE &+1**_d;;E%88J'' z'JJNQJ$7RYYz&YAAA  vvbhh/0011,,,RXXe__jq,QQ*+'"">#3!"<> )*VV !/.1I1I1M M *,''2Dq2H!W*U*U ',6+[8- ) +;[HIQN  , Y Y$W.@.I%IJ__w|,gG- ((!3G!>V3r)rFN)sklearn.utils._array_apirrrNrrrQsXAEK4K4K4K4K4K4r