0PhdZddlZddlZddlZddlmZddlZddlZddlm Z ddl m Z ddl mZddlmZdd hZd;d Zd;d Zd ZdZd efddZdZdZdZdZdZdZdZdZdZ GddZ!e!Z"d efddZ#d efdddZ$d efddZ%dd%Z*d?d&Z+d?d'Z,d?d(Z- d@ddd)d*Z.d>+ , , 3 3N 9!!6 4 3s #ct|tjtjfs$t |drt dsdS|jS)z0Hardware device where the array data resides on.rr*N) isinstancer ndarraygenerichasattrrr)arrays r_single_array_devicer6sT 55=%-899 uh'' ||01 t|r remove_none remove_typesc t|||d}|sdSt|d}|ddD]F}t|}||kr/tdt|dt|G|S)aDHardware device where the array data resides on. If the hardware device is not the same for all arrays, an error is raised. Parameters ---------- *array_list : arrays List of array instances from NumPy or an array API compatible library. remove_none : bool, default=True Whether to ignore None objects passed in array_list. remove_types : tuple or list, default=(str,) Types to ignore in array_list. Returns ------- out : device `device` object (see the "Device Support" section of the array API spec). r7Nrrz$Input arrays use different devices: z, )_remove_non_arraysr6 ValueErrorstr)r8r9 array_listdevice_r5 device_others rrrs*$ <J t":a=11G ABB+E22 l " "'s7||''|$$''  # Nrc4tj|jS)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 rsizerFs 9QW  rc|jtvS)z%Return True if xp is backed by NumPy.)__name__rxps r_is_numpy_namespacerKs ;0 00rctt|r?ddlm}||||\}}|t j||S|j|jcxkrdksnJ||||||gS)Nr) cached_uniquerI) rK_uniquerMasarrayr union1dndim unique_valuesconcat)abrJrMa_uniqueb_uniques r_union1drXs2=*******]1aB777(zz%-(;;<<< 6QV q  BIIr'7'7':':Bzisdtype..s2BB?5!333BBBBBBrrI)r1tupleanyr])rkindrJs` `risdtyperesS $3BBBBBTBBBBBBudr2222rct|tr.|dkr jkS|dkrjjjjhvS|dkrjjj j hvS|dkrtfddDS|dkrtvS|dkrft}td r|jtd r|j|vS|d krtfd d DSt%d||kS)Nboolsigned integerunsigned integerintegralc3<K|]}t|VdSr[r\r^s rraz"_isdtype_single..F qR000r)rhri real floatingcomplex floating complex64 complex128numericc3<K|]}t|VdSr[r\r^s rraz"_isdtype_single..rlr)rjrmrnzUnrecognized data type kind: )r1r=rgint8int16int32int64uint8uint16uint32uint64rcsupported_float_dtypessetr4addrorpr<)rrdrJcomplex_dtypess` ` rr]r]s$ 6>>BG# # % % %RWbh"(CC C ' ' 'RXry")RYGG G Z  ? _ $ $22666 6 ' ' ' UUNr;'' 1""2<000r<(( 2""2=111N* * Y  J  ETEEFF F}rcft|dr|j|j|jfS|j|jfS)aASupported floating point types for the namespace. Note: float16 is not officially part of the Array API spec at the time of writing but scikit-learn estimators and functions can choose to accept it when xp.float16 is defined. https://data-apis.org/array-api/latest/API_specification/data_types.html float16)r4rrrrIs rr{r{s8r9( BJ 33 BJ''rcnt|\}|rt|fd|DS|S)aEnsure that all arrays use the same namespace and device as reference. If necessary the arrays are moved to the same namespace and device as the reference array. Parameters ---------- reference : array Reference array. *arrays : array Arrays to check. Returns ------- arrays : list Arrays with the same namespace and device as reference. c>g|]}|S)r)rO)r_rTr?rJs r z2ensure_common_namespace_device..6s)>>>! 1W -->>>r) get_namespacer) referencearrays is_array_apir?rJs @@rensure_common_namespace_devicersO&%Y//B ##>>>>>v>>>> rc2|dvrtd|dS)N>NrzUnsupported device for NumPy: )r<rs r_check_device_cpur;s, ]""D&DDEEE#"rc<tfd}|S)NcZt|dd|i|S)Nr)rpop)argskwargsfuncs r wrapped_funcz(_accept_device_cpu..wrapped_funcAs4&**Xt44555tT$V$$$rr)rrs` r_accept_device_cpur@s4 4[[%%%%[% rceZdZdZhdZhdZdZedZdddd Z d d d d d Z d Z dZ dZ dZd ddZd ddZdZdZd S)_NumPyAPIWrapperaArray API compat wrapper for any numpy version NumPy < 2 does not implement the namespace. NumPy 2 and later should progressively implement more an more of the latest Array API spec but this is still work in progress at this time. This wrapper makes it possible to write code that uses the standard Array API while working with any version of NumPy supported by scikit-learn. See the `get_namespace()` public function for more details. > eyefullonesemptyzerosarangelinspace full_like ones_like empty_like zeros_like> rsrtrurvrwrxryrzrrrrorpctt|}||jvrt|S||jvrtj|S|SN)getattrr _CREATION_FUNCSr_DTYPESr)selfnameattrs r __getattr__z_NumPyAPIWrapper.__getattr__}sSud## 4' ' '%d++ + 4<  ;t$$ $ rctjSr)r bool_)rs rrgz_NumPyAPIWrapper.bools {rTunsafecopycastingc2||||S)Nr)astype)rrErrrs rrz_NumPyAPIWrapper.astypesxxD'x:::rN)rrrct||durtj|d|Stj||S)NT)rrr)rr r5rO)rrErrrs rrOz_NumPyAPIWrapper.asarraysE&!!! 4<<;qt5999 9=%000 0rc.tj|dS)NT)return_inverser uniquerrEs runique_inversez_NumPyAPIWrapper.unique_inverses|Ad3333rc.tj|dS)NT) return_countsrrs r unique_countsz_NumPyAPIWrapper.unique_countss|AT2222rc*tj|Srrrs rrRz_NumPyAPIWrapper.unique_valuess|Arc2tj|dddS)NT) return_indexrrrrs r unique_allz_NumPyAPIWrapper.unique_alls$| DT    raxisc.tj||S)Nr)r concatenate)rrrs rrSz_NumPyAPIWrapper.concats d3333r)rct|ts"td|dt||dur|}t j||S)zGives a new shape to an array without changing its data. The Array API specification requires shape to be a tuple. https://data-apis.org/array-api/latest/API_specification/generated/array_api.reshape.html zshape must be a tuple, got z of type T)r1rb TypeErrortyperr reshape)rrErDrs rrz_NumPyAPIWrapper.reshapesk %'' MeMMU MM  4<<A}Q&&&rcJ t|||S#t$rYdSwxYw)NrIF)rer)rrrds rrez_NumPyAPIWrapper.isdtypes@ 5$4000 0    55  s  ""c,tj||Sr)r power)rx1x2s rpowz_NumPyAPIWrapper.pows{2r"""r)rH __module__ __qualname____doc__rrrpropertyrgrrOrrrRrrSrrerrrrrIsB  $   OG$   X(,X;;;;;#'t$11111444333   &*44444)- ' ' ' ' '   #####rrcg}t|}|D]B}|r|t||rtj|r-||C|S)aPFilter arrays to exclude None and/or specific types. Raise ValueError if no arrays are left after filtering. 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. )rbr1spissparseappend)r8r9rfiltered_arraysr5s rr;r;s{0O&&L&&  5=  e\ * *   ;u    u%%%% r)r8r9rJc0td}|s||dfStdfS||dfSt|||d}|s tdfSt|ddl}|j|d}}|jdkr&t|dr|d ||fS) aGet 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, an instance of the `_NumPyAPIWrapper` compatibility wrapper 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 an instance of the `_NumPyAPIWrapper` compatibility wrapper 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 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. r*NFTr7rr set_array_api_strict_flagsz2023.12) api_version) r_NUMPY_API_WRAPPER_INSTANCEr;r/r"rrHr4r)r8r9rJrr*r" namespaceis_array_api_compliants rrrsn$&:; 6 >u9 .5 5 ~4x  !F 2*E110111 (F(8(F(OQU%I///G/55/ ,,,CCC , ,,rct|||d}tdg}t|i|\}}t|i|}|r|||fS|d|fS)a Combination 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. 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). r7F)r;dictrr)r8r9r>skip_remove_kwargsrJr arrays_devices rget_namespace_and_devicerMs.$ !J %bAAA$jG4FGGB J=*<==M(<..5-''rct||\}}t|r9|tjt j|Sdd|| zz S)NrIg?)rrKrOspecialexpitr exp)XrJ_s r_expitrtsj ! # # #EB2;zz'- a(8(899::: #r " ##rFc|jdkr$tdt|j|||jt |}d}|jddz}|s|jd|jdz}||d}|r|d||xx|z cc<dS||d||<dS)a Implementation 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 rrNr)rQr<rbrDrOrrr)r5valuerJ add_valuewrapendstep array_flats r_fill_or_add_to_diagonalr|s zQ Mu{9K9K M M    JJuEKu J F FE C ;q>A D .k!nu{1~-E5))J&9C9& % 9C9rcx|j}|dvr)t|dr|jS|jS)zJReturn the float dtype with the highest precision supported by the device.array_api_compat.torchr r)rHr= startswithrr)rJrxp_names r_max_precision_float_dtypersEkG555 F u%%6z :rcd|D}fd|D}|r j|SdjS)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. c2g|]}t|d|Sr)r4)r_rTs rrz1_find_matching_floating_dtype..s'>>>1'!W*=*=>Q>>>rcTg|]$}|jd|j%S)rm)rer)r_rTrJs rrz1_find_matching_floating_dtype..s@"**QWo*N*N r) result_typerOr)rJr dtyped_arraysfloating_dtypess` r_find_matching_floating_dtypersn?>>>>M&O0r~// ::c??  rc `t||\}}}t|rX|r*|tj|||S|*|(|tj||S|||}||||}||j|jkr|:tdt|jdt|jdt|j|j|fkr=tdt|jdt|jd |d d g|j z}|j|||<| ||}| |j d rtd |*| |j d rtd t|||}|||}||r|jn|j||S|||}|||||} |s| S|||} || dkrt+d| | z S)aPartial 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. )rweightsNrz+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=.rrnz;Complex floating point values are not supported by average.rIrrz(Weights sum to zero, can't be normalized)rrKrOr averagedotrDrrbr<rQrrerNotImplementedErrorrrmeansummultiplyrcZeroDivisionError) rTrr normalizerJrr?rD output_dtypesum_scales r_averagers.a99NB725  5::emAD'JJJKK K \g1::ei73344 4 1W %%A**WW*55qw'-77 <:eAGnn:: //:::    AGDM#3 3 3I% 2F2FII+0>>II@DIII  af gdmd **We,, zz!'-.. ! I   rzz'-9KLL! I   1GCCCL !\""A090"&!$????ii..G 66"++a))6 5 5D  FF7F & &E vveslL JKKK %<rc &t||\}}t|r)|tj||S||}|||||j t|||}| ||}| |r/||||j |}|SNrIrr) rrKrOr nanminisnanminwhereinfrallrcnanrrrJrmasks r_nanminr ! # # #EB2 zz%,qt444555xx{{ FF288D"**bfWVAYY*"G"GKKRVF W Wvvdv&& 66$<< 6rzz"&11155Arc &t||\}}t|r)|tj||S||}|||||j t|||}| ||}| |r/||||j |}|Sr) rrKrOr nanmaxrmaxrrrrrcrrs r_nanmaxr#rrc t||\}}t|r)|tj||S||}||||dt|||}|| | ||j |}||z S)NrIrrr) rrKrOr nanmeanrr rrr logical_notr)rrrJrrtotalcounts r_nanmeanr)%s ! # # #EB2zz%-555666xx{{rxxbjjVAYYj&G&GKKRVWWryy!5!5qw??dKKu}r)rJrc t||\}}t|rH|durtj|||}ntj|||}||S|||||S)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. rIT)orderr)rrr)rrKr r5rO)r5rr+rrJrrs r_asarray_with_orderr,2s %B ' ' 'EB2 H 4<<KU%@@@EEM%uEBBBEzz%   zz%u4zGGGrct||\}}t|r=tj|}|tj|dS||dS)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. rIC)r+r)rD)rrKr rOravelr)r5rJrs r_ravelr0Psp %B ' ' 'EB29 e$$zz%+e3777888 ::e5: ) ))rc|j}|dvr&|S|dvr|Stj|S)z*Convert X into a NumPy ndarray on the CPU.r>array_api_compat.cupyr )rHrr r(rO)r5rJrs r_convert_to_numpyr3^sYkG555yy{{  """ 5 5 5yy{{ =  rcddlm}||}t|D]K\}}t |dst |t jr ||}t|||L|S)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.baser5varsitemsr4r1r r2setattr) estimator converterr5 new_estimatorkey attributes r _estimator_with_converted_arraysr@js&#"""""E)$$My////11//Y 9l + + -z)U]/S/S -! ),,I sI.... rcV| tj}tj|jdzS)z6Return the absolute tolerance for a given numpy dtype.Nd)r rfinfoeps)dtype_or_dtype_names r_atol_for_typerFs+"$m ;* + + /# 55rc6|djS)aMReturn 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)rOrrIs rindexing_dtyperHs* ::a== rleft)sidesorterrJc:t|||\}}t|dr|||||St||}t||}t j||||}||t |S)NrI searchsorted)rJrKr)rr4rMr3r rOr) rTvrJrKrJra_npv_npindicess r _searchsortedrRs !Q2 & & &EBr>""?q!$v>>> Q2 & & &D Q2 & & &D t$vFFFG ::gfQii: 0 00rc.t|r*|tj|||S|r||d}n*||}||}|t |||ddS)ziFind the set difference of two arrays. Return the unique values in `ar1` that are not in `ar2`. )ar1ar2 assume_uniquerTrTrUrJrVinvert)rKrOr setdiff1drrR_in1d)rTrUrJrVs r _setdiff1dr[s 2 zz O+      $jje$$s##s## u#"DNNN OOrc ,t|r+|tj||||S|j}||d}||d}|t ||||||S)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_elementsrVrXrrW)rKrOr isinrDrrZ)r]r^rJrVrXoriginal_element_shapes r_isinras2 zz J++       %]jj%((GJJ}e44M :: '        rct|||\}}|jdd|jddzzkr|rD||jd|jt |}|D] }|||kz} nC||jd|jt |}|D] }|||kz} |S|s-||\}}||}|||f} t | } | | d} | | d} | | | d} |r| d d | d d k}n| d d | d d k}||| |g| f}| || d}|r|d |jdS| ||dS) aChecks 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 rIr g(\?rT)stablerrNrr) rrDrrgrrrrRrSargsorttakerO)rTrUrJrVrXrrrTrev_idxarr?r+ reverse_ordersarbool_arflagrets rrZrZs  #sr * * *EB y|b39Q<50000  !7739QSYq\>""wwsG!w,,,rc0ddlm}t|||\}}t|r"t j|r||||S|jdksJ|||}|X|||}| ||j ddf}| ||j |z}|d||j }| ||dk||| S) 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_nonzerorI)r sample_weightrrNr)rrr) sparsefuncsrorrKrrrQrrOrrDrrr r) rrrprJrrorr zero_scalars r_count_nonzerors s# +***** !]r 2 2 2EB2H2;q>>H}QTGGGG 6Q;;;;ll1Vl,,G  = @@  ==3Fq3I12MNN ))G]%899MI**QvW]*CCK 66"((167K88t6 D DDr)outcJt|r ||d|i|n||i|}|S)Nrt)rK)rJrrtrrs r_modify_in_place_if_numpyrv8sH2$ d&&v&&&&dD#F## Jrc>t||\}}t|dr||||St||}|t||}nd}t j|||}||t |S)NrIbincount)r minlengthr)rr4rxr3r rOr)r5rryrJrarray_np weights_npbin_outs r _bincountr}@s %B ' ' 'EBr:H{{5'Y{GGG 2...H&w2666  nXzYOOOG ::gfUmm: 4 44rct||\}}t|r|St||}d|DS)NrIc6g|]}|Sr)item)r_r]s rrz_tolist..Us 3 3 3wGLLNN 3 3 3r)rrKtolistr3)r5rJrrzs r_tolistrPs\ %B ' ' 'EB2||~~ 2...H 3 3( 3 3 33r)Tr)TF)NNTN)NN)NNN)F)FF)NNNN)rs0!!    !#;<>!.!.!.!.H'''T"%)v*****Z    111 SSS 3 3 3D ( ( (:FFF |#|#|#|#|#|#|#|#~/.00-1v#####L(,3&TY-Y-Y-Y-Y-x7;#$($($($($(N$$$$&&&&@   !!!2????D""    )-H48HHHHH< * * * *    :6660!'t 1 1 1 1 1PPPP,D--------`EEEE048 5 5 5 5 444444r