-i(SrSSKrSSKrSSKrSSKJr SSKrSSKrSSKJ r SSK J r SSK Jr SSKJr SSKJr SSKJr S S KJr S /rS S 1rS>SjrS>SjrSrSrSrS\4S.SjrSr Sr!Sr"Sr#Sr$Sr%Sr&Sr'Sr(S\4S.Sjr)S\4SS .S!jr*S\4SS .S"jr+S?S#jr,S@S$jr-S%r.S&r/S'r0SAS(jr1S?S)jr2SBS*jr3SBS+jr4SBS,jr5SCSSS-.S.jjr6S?S/jr7S0r8S1r9S2r:S3r;S4SSS5.S6jrSES9jr?SS:.S;jr@SCS<jrAS?S=jrBg)FzTools to support array_api.Nwraps) get_config)array_api_compat)array_api_extra)numpy) parse_versionxpxr z(sklearn.externals.array_api_compat.numpyTc#L# SHnU(d U[;aMUv M g7f)aYield supported namespace. This is meant to be used for testing purposes only. Parameters ---------- include_numpy_namespaces : bool, default=True If True, also yield numpy namespaces. Returns ------- array_namespace : str The name of the Array API namespace. )r array_api_strictcupytorchN)_NUMPY_NAMESPACE_NAMES)include_numpy_namespacesarray_namespaces K/var/www/html/venv/lib/python3.13/site-packages/sklearn/utils/_array_api.pyyield_namespacesrs' (O?U,U  s"$c#P# [US9HvnUS:Xa/[R"SS5H up#XU4v M USS4v M8US:Xa1SS KnXR S 5S 4v XR S 5S4v MoUS S 4v Mx g ![ a US S 4v US S4v Mf=f7f) aYield supported namespace, device, dtype tuples for testing. Use this to test that an estimator works with all combinations. Use in conjunction with `ids=_get_namespace_device_dtype_ids` to give clearer pytest parametrization ID names. Parameters ---------- include_numpy_namespaces : bool, default=True If True, also yield numpy namespaces. Returns ------- array_namespace : str The name of the Array API namespace. device : str The name of the device on which to allocate the arrays. Can be None to indicate that the default value should be used. dtype_name : str The name of the data type to use for arrays. Can be None to indicate that the default value should be used. )rr)cpucuda)float64float32mpsrrrN CPU_DEVICErdevice1)r itertoolsproductrDevice ImportError)rrdevicedtypers r)yield_namespace_device_dtype_combinationsr$;s2,!9 g %!*!2!2!7" &u44""5)3 3  2 2 <'%'>'>|'LiWW%'>'>y'I9TT"4- -/  <&|Y>>%y);;  Nrr z$Input arrays use different devices: z, )_remove_non_arraysr= ValueError)r?r@ array_listdevice_r< device_others rr"r"so*$ <J ":a=1G AB+E2  "6wir,P   Nr6cB[R"UR5$)zReturn the total number of elements of x. Parameters ---------- x : array Array instance from NumPy or an array API compatible library. Returns ------- out : int Total number of elements. )mathprodshape)xs rsizerLs 99QWW r6c(UR[;$)z%Return True if xp is backed by NumPy.)__name__rxps r_is_numpy_namespacerQs ;;0 00r6cV[U5(a4SSKJn U"XUS9upEUR[R "XE55$UR UR s=:XaS:Xde eURURURU5URU5/55$)Nr ) cached_uniquerO) rQ_uniquerSasarrayr union1dndim unique_valuesconcat)abrPrSa_uniqueb_uniques r_union1dr^s2**1B7zz%--;<< 66QVV q    BIIr'7'7':B# UHn[TUTS9v M g7frON_isdtype_single.0kr#rPs r isdtype..sBT?5!3TrO)r8tupleanyrc)r#kindrPs` `risdtyperms2 $BTBBBudr22r6c^^[U[5(GaKUS:XaTTR:H$US:Xa1TTRTRTR TR 1;$US:Xa1TTRTRTRTR1;$US:Xa[UU4SjS55$US:XaT[T5;$US:Xag[5n[TS 5(aURTR 5 [TS 5(aURTR"5 TU;$US :Xa[UU4S jS 55$[%SU<35eTU:H$)Nboolsigned integerunsigned integerintegralc3:># UHn[TUTS9v M g7frarbrds rrg"_isdtype_single.. s!?A qR0?ri)rprq real floatingcomplex floating complex64 complex128numericc3:># UHn[TUTS9v M g7frarbrds rrgrts!JA qR0Jri)rrrurvzUnrecognized data type kind: )r8strroint8int16int32int64uint8uint16uint32uint64rksupported_float_dtypessetr;addrwrxrC)r#rlrPcomplex_dtypess` ` rrcrcsW$ 6>BGG# # % %RWWbhh"((CC C ' 'RXXryy"))RYYGG G Z ? _ $2266 6 ' ' UNr;''""2<<0r<((""2==1N* * Y J  v! 1 -v>> ?sAc.US;a[SU<35eg)N>NrzUnsupported device for NumPy: )rCrs r_check_device_cpurQs" ]"9&DEE#r6c0^[T5U4Sj5nU$)NcJ>[URSS55 T"U0UD6$)Nr")rpop)argskwargsfuncs r wrapped_func(_accept_device_cpu..wrapped_funcWs&&**Xt45T$V$$r6r)rrs` r_accept_device_cpurVs! 4[%% r6c/n[U5nUHOnU(aUcM[XA5(aM![R"U5(aM>UR U5 MQ U$)aFilter arrays to exclude None and/or specific types. Sparse arrays are always filtered out. Parameters ---------- *arrays : array objects Array objects. remove_none : bool, default=True Whether to ignore None objects passed in arrays. remove_types : tuple or list, default=(str,) Types to ignore in the arrays. Returns ------- filtered_arrays : list List of arrays filtered as requested. An empty list is returned if no input passes the filters. )rjr8spissparseappend)r?r@rfiltered_arraysr<s rrBrB_s],O&L 5=  e * *  ;;u   u% r6)r?r@rPc0[5SnU(dUbUS4$[S4$UbUS4$[UUUS.6nU(d[S4$[U5 [R "U6SpeUR S:Xa [US5(aURSS9 XV4$) a+Get namespace of arrays. Introspect `arrays` arguments and return their common Array API compatible namespace object, if any. Note that sparse arrays are filtered by default. See: https://numpy.org/neps/nep-0047-array-api-standard.html If `arrays` are regular numpy arrays, `array_api_compat.numpy` is returned instead. Namespace support is not enabled by default. To enabled it call: sklearn.set_config(array_api_dispatch=True) or: with sklearn.config_context(array_api_dispatch=True): # your code here Otherwise `array_api_compat.numpy` is always returned irrespective of the fact that arrays implement the `__array_namespace__` protocol or not. Note that if no arrays pass the set filters, ``_NUMPY_API_WRAPPER_INSTANCE, False`` is returned. Parameters ---------- *arrays : array objects Array objects. remove_none : bool, default=True Whether to ignore None objects passed in arrays. remove_types : tuple or list, default=(str,) Types to ignore in the arrays. xp : module, default=None Precomputed array namespace module. When passed, typically from a caller that has already performed inspection of its own inputs, skips array namespace inspection. Returns ------- namespace : module Namespace shared by array objects. If any of the `arrays` are not arrays, the namespace defaults to the NumPy namespace. is_array_api_compliant : bool True if the arrays are containers that implement the array API spec (see https://data-apis.org/array-api/latest/index.html). Always False when array_api_dispatch=False. r2FTr>rset_array_api_strict_flagsz2024.12) api_version) r np_compatrBr5rrrNr;r)r?r@rPrr2 namespaceis_array_api_compliants rrrsn$&:;  >u9 e# # ~4x  !F %01(8(F(F(OQU%//G/55 ,,,C  ,,r6c[S/S9n[UUUS.6n[U0UD6nUc[U0UD6up&OUSpbU(aX&U4$USU4$)aCombination into one single function of `get_namespace` and `device`. Parameters ---------- *array_list : array objects Array objects. remove_none : bool, default=True Whether to ignore None objects passed in arrays. remove_types : tuple or list, default=(str,) Types to ignore in the arrays. xp : module, default=None Precomputed array namespace module. When passed, typically from a caller that has already performed inspection of its own inputs, skips array namespace inspection. Returns ------- namespace : module Namespace shared by array objects. If any of the `arrays` are not arrays, the namespace defaults to NumPy. is_array_api_compliant : bool True if the arrays are containers that implement the Array API spec. Always False when array_api_dispatch=False. device : device `device` object (see the "Device Support" section of the array API spec). Fr>T)dictrBr"r)r?r@rPrDskip_remove_kwargs arrays_devicers rget_namespace_and_devicersr:%bA# !J J=*<=M z(*K8JKLtL..5-''r6c[XS9up[U5(a9UR[R"[ R"U555$SSUR U*5-- $)NrOg?)rrQrUspecialexpitr exp)XrP_s r_expitr sT ! #EB2zz'-- a(89:: #r " ##r6c~URS:wa![S[UR535eUR XR [ U5S9nSnURSS-nU(dURSURS-nURUS5nU(aUSXV2==U- ss'gXSXV2'g)aImplementation to facilitate adding or assigning specified values to the diagonal of a 2-d array. If ``add_value`` is `True` then the values will be added to the diagonal elements otherwise the values will be assigned to the diagonal elements. By default, ``add_value`` is set to `True. This is currently only supported for 2-d arrays. The implementation is taken from the `numpy.fill_diagonal` function: https://github.com/numpy/numpy/blob/v2.0.0/numpy/lib/_index_tricks_impl.py#L799-L929 rz*array should be 2-d. Got array with shape r#r"Nr )rWrCrjrJrUr#r"reshape)r<valuerP add_valuewrapendstep array_flats r_fill_or_add_to_diagonalrs zzQ8u{{9K8L M   JJuKKu J FE C ;;q>A D kk!nu{{1~-E5)J9C9& %9C9r6c2URUSU3SU34;$)Nzarray_api_compat.z#sklearn.externals.array_api_compat.)rN)rPnames r_is_xp_namespacer2s/ ;; D6" -dV4 r6c[US5(a+[U5RS5(a UR$UR$)zJReturn the float dtype with the highest precision supported by the device.rr)rr{ startswithrrrPr"s r_max_precision_float_dtyper:s@G$$V)?)? **zz ::r6c\UVs/sH'n[US5(dMURU5PM) nnUVs/sH1o RURS5(dM%URPM3 nnU(aUR"U6$URS5R$s snfs snf)aFind a suitable floating point dtype when computing with arrays. If any of the arrays are floating point, return the dtype with the highest precision by following official type promotion rules: https://data-apis.org/array-api/latest/API_specification/type_promotion.html If there are no floating point input arrays (all integral inputs for instance), return the default floating point dtype for the namespace. r#ru)r;rUrmr# result_type)rPrrZ dtyped_arraysfloating_dtypess r_find_matching_floating_dtyperEs-3JFqga6I]RZZ]FMJ&&A**QWWo*N~~// ::c?  KsB$B$$B)!B)c 2[X5upEn[U5(aVU(a$UR[R"XUS95$Uc(Ub%UR[R "X55$URXS9nUbURX&S9nUbUR UR :waUc8[S[UR 5S[UR 5S35e[UR 5UR U4:wa<[S[UR 5S[UR 5SU<S 35eS /UR-nUR UXq'URU[U55nURURS 5(a [S 5eUb,URURS 5(a [S 5e[XUS 9nUR!X5nUc#U(a UR"O UR$"XS9$UR!X(5nUR%UR'X5US9n U(dU $UR%X!S9n UR)U S:H5(a [+S5eX- $)zPartial port of np.average to support the Array API. It does a best effort at mimicking the return dtype rule described at https://numpy.org/doc/stable/reference/generated/numpy.average.html but only for the common cases needed in scikit-learn. )axisweightsrz+Axis must be specified when the shape of a z and weights z differ.zShape of weights weights.shape=z! must be consistent with a.shape=z and axis=.r rvz;Complex floating point values are not supported by average.rOrrz(Weights sum to zero, can't be normalized)rrQrUr averagedotrJ TypeErrorrjrCrWrrmr#NotImplementedErrorrastypemeansummultiplyrkZeroDivisionError) rZrr normalizerPrrErJ output_dtypesum_scales r_averager^s].a9NB72 ::emmA'JK K \g1::eii34 4 1 %A**W*5qww'--7 <=eAGGn=MN /0:   AGGDM#3 31% 2F1GH++0>*:+waI  aff ggdm **WeEl3 zz!''-..! I  rzz'--9KLL! I  1CL !"A$"&&0!??ii.G 66"++a)6 5D  FF7F &E vvesl JKK <r6c [XUS9up#n[R"SSS9 XRU5-nSSS5 UR US:HUR SWR US9U5$!,(df  N==f)NrOignore)divideinvalidrr)rr errstatelogwhererUr#)rKyrPrrEtemps r_xlogyrsh-ar:NB7 x :66!9} ; 88AHbjjDJJwjOQU VV ; :s A.. A<c [XS9up#n[U5(a#UR[R"XS95$UR U5nUR URXRRUR7URUS9U5US9nURXQS9nURU5(a5URXRRURURUS9U5nU$NrOrr) rrQrUr nanminisnanminrinfr#allrknanrrrPrrEmasks r_nanminr.a7NB72zz%,,q455xx{ FF HHT::rvvgQWWW:Mq Q   vvdv& 66$<<zz"&&zPRSTAr6c [XS9up#n[U5(a#UR[R"XS95$UR U5nUR URXRRUR*URUS9U5US9nURXQS9nURU5(a5URXRRURURUS9U5nU$r) rrQrUr nanmaxrmaxrrr#rrkrrs r_nanmaxrrr6c [XS9up#n[U5(a#UR[R"XS95$UR U5nUR URXRRSURUS9U5US9nUR URURU5UR5US9nXg- $)NrOrrr) rrQrUr nanmeanrrrr#r logical_not)rrrPrrErtotalcounts r_nanmeanrs.a7NB72zz%--566xx{ HHT::c:I1 MTX ryy!5qww?dK}r6rc[XS9upF[U5(aAUSLa[R"XUS9nO[R"XUS9nUR U5$UR XX5S9$)aHelper to support the order kwarg only for NumPy-backed arrays Memory layout parameter `order` is not exposed in the Array API standard, however some input validation code in scikit-learn needs to work both for classes and functions that will leverage Array API only operations and for code that inherently relies on NumPy backed data containers with specific memory layout constraints (e.g. our own Cython code). The purpose of this helper is to make it possible to share code for data container validation without memory copies for both downstream use cases: the `order` parameter is only enforced if the input array implementation is NumPy based, otherwise `order` is just silently ignored. rOT)orderr#)r#copyr")rrQr r<rU)r<r#rrrPr"rs r_asarray_with_orderrsf % 'EB2 4<KK%@EMM%EBEzz%  zz%4zGGr6c[XS9up[U5(a:[R"U5nUR[R"USS95$UR USS9$)zArray API compliant version of np.ravel. For non numpy namespaces, it just returns a flattened array, that might be or not be a copy. rOC)rr)rJ)rrQr rUravelr)r<rPrs r_ravelrsV % 'EB2 e$zz%++e3788 ::e5: ))r6cT[US5(aUR5R5$[US5(aUR5$[US5(a2[R"UR XR S5S95$[R"U5$)z*Convert X into a NumPy ndarray on the CPU.rrrrr)rrr r0rUr )r<rPs r_convert_to_numpyr s}G$$yy{  "" "f % %yy{ "0 1 1}}RZZii 6MZNOO == r6cSSKJn U"U5n[U5R5HIupE[ US5(d[ U[ R5(aU"U5n[X4U5 MK U$)aCreate new estimator which converting all attributes that are arrays. The converter is called on all NumPy arrays and arrays that support the `DLPack interface `__. Parameters ---------- estimator : Estimator Estimator to convert converter : callable Callable that takes an array attribute and returns the converted array. Returns ------- new_estimator : Estimator Convert estimator r)clone __dlpack__) sklearn.baser varsitemsr;r8r r9setattr) estimator converterr  new_estimatorkey attributes r _estimator_with_converted_arraysrsc&#)$My///1 9l + +z)U]]/S/S!),I I.2 r6cnUc[Rn[R"U5RS-$)z6Return the absolute tolerance for a given numpy dtype.d)r rfinfoeps)dtype_or_dtype_names r_atol_for_typer5s/"$mm ;;* + / /# 55r6c8URS5R$)a-Return a platform-specific integer dtype suitable for indexing. On 32-bit platforms, this will typically return int32 and int64 otherwise. Note: using dtype is recommended for indexing transient array datastructures. For long-lived arrays, such as the fitted attributes of estimators, it is instead recommended to use platform-independent int32 if we do not expect to index more 2B elements. Using fixed dtypes simplifies the handling of serialized models, e.g. to deploy a model fit on a 64-bit platform to a target 32-bit platform such as WASM/pyodide. r)rUr#rOs rindexing_dtyper?s* ::a=  r6left)sidesorterrPc[XUS9upE[US5(aURXX#S9$[XS9n[XS9n[R"XgX#S9nUR U[ U5S9$)NrO searchsorted)rr r)rr;r"rr rUr") rZvrr rPra_npv_npindicess r _searchsortedr'Wso !2 &EBr>""q$>> Q &D Q &D  $FG ::gfQi: 00r6c [U5(a&UR[R"UUUUS95$URnUR US5nUR US5nUR [ UUUUUS9U5$)zCalculates ``element in test_elements``, broadcasting over `element` only. Returns a boolean array of the same shape as `element` that is True where an element of `element` is in `test_elements` and False otherwise. )element test_elements assume_uniqueinvertr)ar1ar2rPr+r,)rQrUr isinrJr_in1d)r)r*rPr+r,original_element_shapes r_isinr2fs2zz JJ++    %]]jj%(GJJ}e4M :: '     r6c[XUS9up%URSSURSS--:aU(aCURURSUR[ U5S9nUH nX`U:g-nM U$UR URSUR[ U5S9nUH nX`U:H-nM U$U(d$UR U5upURU5nURX45n [ U 5n URU SS9n URU SS9n URXSS9n [U 5S :aU(a U S S U S S :gO U S S U S S :HnO+U(aURS /5OURS/5nURXRU/U S 945nURXSS9nU(aUS URS$URUWSS9$)ahChecks whether each element of an array is also present in a second array. Returns a boolean array the same length as `ar1` that is True where an element of `ar1` is in `ar2` and False otherwise. This function has been adapted using the original implementation present in numpy: https://github.com/numpy/numpy/blob/v1.26.0/numpy/lib/arraysetops.py#L524-L758 rOr g(\?rT)stablerr NrFr) rrJonesror"zerosunique_inverserXrYargsorttakerLrU)r-r.rPr+r,rrrZrev_idxarrEr reverse_ordersarbool_arflagrets rr0r0s #r *EB yy|b399Q<5000 77399QSYYq\""wwsG!w,,r6cSSKJn [XUS9up6[U5(a"[R "U5(aU"XUS9$UR S:XdeURXS9nUbMURX$S9nURX"RSS45nURXrR5U-nURSXGRS9nURURUS:gXx5US 9$) zA variant of `sklearn.utils.sparsefuncs.count_nonzero` for the Array API. If the array `X` is sparse, and we are using the numpy namespace then we simply call the original function. This function only supports 2D arrays. r ) count_nonzerorO)r sample_weightrrr)r"r#r) sparsefuncsrCrrQrrrW ones_likerUrrJrr#rr) rrrDrPr"rCrr zero_scalars r_count_nonzerorHs + !r 2EB22;;q>>QGG 66Q;;ll1l,G  = @  =3F3Fq3I12MN ))G%8%89MI**Qv]]*CK 66"((1678t6 DDr6)outcN[U5(a U"USU0UD6 U$U"U0UD6nU$)NrI)rQ)rPrrIrrs r_modify_in_place_if_numpyrKs<2 d&&v& JD#F# Jr6c[XS9up4[US5(aURXUS9$[XS9nUb [XS9nOSn[R"XVUS9nUR U[ U5S9$)NrObincount)r minlengthr)rr;rMrr rUr")r<rrNrPrarray_np weights_npbin_outs r _bincountrRsv % 'EBr:{{5Y{GG .H&w6  nnXYOG ::gfUm: 44r6c[XS9up[U5(aUR5$[XS9nUVs/sHoDR 5PM sn$s snf)NrO)rrQtolistritem)r<rPrrOr)s r_tolistrVsK % 'EB2||~ .H*2 3(wLLN( 33 3sA)T)N)TF)NNTN)NN)NNN)FF)NNNN)C__doc__rrHr. functoolsrr r, scipy.sparsesparser scipy.specialr_configr externalsrrr externals.array_api_compatrfixesr __all__rrr$r(r5r=r{r"rLrQr^rmrcrrrrrBrrrrrrrrrrrrrrrrrrr'r2r0rHrKrRrVr6rrbsi!    (.;  '!#MN>0.f" 6"%)v)X  1 S 3D (:F -1v!H(,3&TS-n"4.(b$&@!2?DW((  )-H48H< *  :60!'t 1D.-bE048 5 4r6