o X۷i.[@sdZddlmZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl Z zddl Z d ZWn eyAd ZYnwee je jfZee jfZed d d dZeddddZddZddZeddddZddZddZdd Zejd!d"d#d$d d%Z ejd&d'd(d)d d%Z! dAd*d+Z"ed,d-d.d/Z#Gd0d1d1Z$d2d3Z%d4d5Z&d6d7Z'd8d9Z(dBd;d<Z)d=d>Z*d?d@Z+dS)Cz*Indexing mixin for sparse matrix classes. ) annotationsN)_core) isspmatrix)spmatrix)device)runtimeTFzT d, S ind, int32 minorz raw T answerz+if (ind == minor) atomicAdd(&answer[0], d);#cupyx_scipy_sparse_compress_getitemz"T real, T imag, S ind, int32 minorz$raw T answer_real, raw T answer_imagzo if (ind == minor) { atomicAdd(&answer_real[0], real); atomicAdd(&answer_imag[0], imag); } +cupyx_scipy_sparse_compress_getitem_complexc CsT|||d}t|dt|d}}||}|||}|||} | ||fS)aEReturn a submatrix of the input sparse matrix by slicing major axis. Args: Ax (cupy.ndarray): data array from input sparse matrix Aj (cupy.ndarray): indices array from input sparse matrix Ap (cupy.ndarray): indptr array from input sparse matrix start (int): starting index of major axis stop (int): ending index of major axis Returns: Bx (cupy.ndarray): data array of output sparse matrix Bj (cupy.ndarray): indices array of output sparse matrix Bp (cupy.ndarray): indptr array of output sparse matrix r)int) AxAjApstartstop start_offset stop_offsetBpBjBxrO/home/ubuntu/vllm_env/lib/python3.10/site-packages/cupyx/scipy/sparse/_index.py_get_csr_submatrix_major_axis-s    rc Csn||k||k@}tj|jd|jd}d|d<||dd<tj||d||}|||}||} | ||fS)aEReturn a submatrix of the input sparse matrix by slicing minor axis. Args: Ax (cupy.ndarray): data array from input sparse matrix Aj (cupy.ndarray): indices array from input sparse matrix Ap (cupy.ndarray): indptr array from input sparse matrix start (int): starting index of minor axis stop (int): ending index of minor axis Returns: Bx (cupy.ndarray): data array of output sparse matrix Bj (cupy.ndarray): indices array of output sparse matrix Bp (cupy.ndarray): indptr array of output sparse matrix r dtyperNout)cupyemptysizercumsum) r rrrrmaskmask_sumrrrrrr_get_csr_submatrix_minor_axisFs   r$zNint32 out_rows, raw I rows, raw int32 Ap, raw int32 Aj, raw T Ax, raw int32 Bpzint32 Bj, T BxaD const I row = rows[out_rows]; // Look up starting offset const I starting_output_offset = Bp[out_rows]; const I output_offset = i - starting_output_offset; const I starting_input_offset = Ap[row]; Bj = Aj[starting_input_offset + output_offset]; Bx = Ax[starting_input_offset + output_offset]; $cupyx_scipy_sparse_csr_row_index_kerc Csxt|}tj|jd|jd}d|d<tj|||dddt|d}t||}t||||||\}} | ||fS)aPopulate indices and data arrays from the given row index Args: Ax (cupy.ndarray): data array from input sparse matrix Aj (cupy.ndarray): indices array from input sparse matrix Ap (cupy.ndarray): indptr array from input sparse matrix rows (cupy.ndarray): index array of rows to populate Returns: Bx (cupy.ndarray): data array of output sparse matrix Bj (cupy.ndarray): indices array of output sparse matrix Bp (cupy.ndarray): indptr array for output sparse matrix r rrNrr ) rdiffrr rr!r _csr_indptr_to_coo_rows_csr_row_index_ker) r rrrowsrow_nnzrnnzout_rowsrrrrr_csr_row_indexss    r-cCsbddlm}tj|tjd}t}tj r|dkrt d| ||j j ||jd|j j |j|S)Nr)cusparserz@hipSPARSE currently cannot handle sparse matrices with null ptrsr )cupy_backends.cuda.libsr.rrnumpyint32rget_cusparse_handleris_hip ValueErrorxcsr2coodataptrr CUSPARSE_INDEX_BASE_ZERO)r+rr.r,handlerrrr's r'c Cstj||d}tj||d}t||g}t||}||}||}||}tj|jdd} t|||| |jdd|| || || fS)z;Find the unique indices for each row and keep only the lastrboolr r )rasarraystacklexsortastypeonesr _unique_mask_kern) ijx idx_dtypestackedorderindptr_insertsindices_inserts data_insertsr"rrr_select_last_indicess rKzqraw I insert_indices, raw T insert_values, raw I insertion_indptr, raw I Ap, raw I Aj, raw T Ax, raw I Bpzraw I Bj, raw T Bxa const I input_row_start = Ap[i]; const I input_row_end = Ap[i+1]; const I input_count = input_row_end - input_row_start; const I insert_row_start = insertion_indptr[i]; const I insert_row_end = insertion_indptr[i+1]; const I insert_count = insert_row_end - insert_row_start; I input_offset = 0; I insert_offset = 0; I output_n = Bp[i]; I cur_existing_index = -1; T cur_existing_value = -1; I cur_insert_index = -1; T cur_insert_value = -1; if(input_offset < input_count) { cur_existing_index = Aj[input_row_start+input_offset]; cur_existing_value = Ax[input_row_start+input_offset]; } if(insert_offset < insert_count) { cur_insert_index = insert_indices[insert_row_start+insert_offset]; cur_insert_value = insert_values[insert_row_start+insert_offset]; } for(I jj = 0; jj < input_count + insert_count; jj++) { // if we have both available, use the lowest one. if(input_offset < input_count && insert_offset < insert_count) { if(cur_existing_index < cur_insert_index) { Bj[output_n] = cur_existing_index; Bx[output_n] = cur_existing_value; ++input_offset; if(input_offset < input_count) { cur_existing_index = Aj[input_row_start+input_offset]; cur_existing_value = Ax[input_row_start+input_offset]; } } else { Bj[output_n] = cur_insert_index; Bx[output_n] = cur_insert_value; ++insert_offset; if(insert_offset < insert_count) { cur_insert_index = insert_indices[insert_row_start+insert_offset]; cur_insert_value = insert_values[insert_row_start+insert_offset]; } } } else if(input_offset < input_count) { Bj[output_n] = cur_existing_index; Bx[output_n] = cur_existing_value; ++input_offset; if(input_offset < input_count) { cur_existing_index = Aj[input_row_start+input_offset]; cur_existing_value = Ax[input_row_start+input_offset]; } } else { Bj[output_n] = cur_insert_index; Bx[output_n] = cur_insert_value; ++insert_offset; if(insert_offset < insert_count) { cur_insert_index = insert_indices[insert_row_start+insert_offset]; cur_insert_value = insert_values[insert_row_start+insert_offset]; } } output_n++; } 1cupyx_scipy_sparse_csr_copy_existing_indices_kern) no_returnz#raw I rows, raw I cols, raw I orderz raw bool maskaT I cur_row = rows[i]; I next_row = rows[i+1]; I cur_col = cols[i]; I next_col = cols[i+1]; I cur_order = order[i]; I next_order = order[i+1]; if(cur_row == next_row && cur_col == next_col) { if(cur_order < next_order) mask[i] = false; else mask[i+1] = false; } #cupyx_scipy_sparse_unique_mask_kernc CsD||dk|7<||dk|7<t|||||||||jd S)aPopulate data array for a set of rows and columns Args n_row : total number of rows in input array n_col : total number of columns in input array Ap : indptr array for input sparse matrix Aj : indices array for input sparse matrix Ax : data array for input sparse matrix Bi : array of rows to extract from input sparse matrix Bj : array of columns to extract from input sparse matrix Returns Bx : data array for output sparse matrix rr;)_csr_sample_values_kernr )n_rown_colrrr Bir not_found_valrrr_csr_sample_values)srTzWI n_row, I n_col, raw I Ap, raw I Aj, raw T Ax, raw I Bi, raw I Bj, I not_found_valzraw T Bxat const I j = Bi[i]; // sample row const I k = Bj[i]; // sample column const I row_start = Ap[j]; const I row_end = Ap[j+1]; T x = 0; bool val_found = false; for(I jj = row_start; jj < row_end; jj++) { if (Aj[jj] == k) { x += Ax[jj]; val_found = true; } } Bx[i] = val_found ? x : not_found_val; )cupyx_scipy_sparse_csr_sample_values_kernc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*S)+ IndexMixinzS This class provides common dispatching and validation logic for indexing. cCstrtjtjdkrtd||\}}t|t r@t|t r&| ||St|t r1| ||S|j dkr<|||Stdt|t rxt|t rP|||St|t ri|t dkrc||krc|S|||S|j dkrt|||Std|j dkrt|t r|||St|t r|||Sn5t|t r|||St|t rtd|jddkr|j dks|jddkr||dddf|St||\}}|j|jkrtd|jdkr|jt|j|jdS|||S)Nz1.4.0z,Sparse __getitem__() requires Scipy >= 1.4.0r zindex results in >2 dimensionsr'number of row and column indices differr) scipy_availabler0lib NumpyVersionscipy __version__NotImplementedError_parse_indices isinstance_int_scalar_types _get_intXintslice_get_intXslicendim_get_intXarray IndexError_get_sliceXintcopy_get_sliceXslice_get_sliceXarray_get_arrayXint_get_arrayXsliceshape_get_columnXarrayravelrbroadcast_arraysr __class__ atleast_2dr_get_arrayXarray)selfkeyrowcolrrr __getitem__\sZ                       &   zIndexMixin.__getitem__c Cs||\}}t|tr.t|tr.tj||jd}|jdkr"td||||j ddSt|t rEtj | |j ddddf}nt|}t|t rntj | |j ddddf}|jdkrm|dddf}nt|}t||\}}|j |j krtdt|r|jdkr|d}|d}|j ddko|j ddk}|j ddko|j ddk}|s|j d|j dkr|s|j d|j dkstd|jdkrdS|jdd}|||||dStj||jd}t||\}} |jdkrdS||j }||||dS) Nrr z&Trying to assign a sequence to an itemrrWzshape mismatch in assignmentT)rh)r^r_r`rr<rr r4 _set_intXintflatrbarangeindicesrm atleast_1drdrprfrtocoosum_duplicates_set_arrayXarray_sparsereshape_set_arrayXarray) rtrurDrvrwrBrC broadcast_row broadcast_col_rrr __setitem__sV   $  "        zIndexMixin.__setitem__cCs.t|tjtjfr|jdkr|jdkrdSdS)Nrr TF)r_rndarrayr0rdr )rtindexrrr _is_scalarszIndexMixin._is_scalarcCs|j\}}t|\}}||r|}||r|}t|tr)t||d}n t|ts4|||}t|trCt||d}||fSt|tsN|||}||fS)Nrvcolumn) rm _unpack_indexritemr_r`_normalize_indexrb _asindices)rtruMNrvrwrrrr^s          zIndexMixin._parse_indicesc CsNz tj||jjd}Wntttfytdw|jdvr#td||S)aConvert `idx` to a valid index for an axis with a given length. Subclasses that need special validation can override this method. idx is assumed to be at least a 1-dimensional array-like, but can have no more than 2 dimensions. rz invalid index)r zIndex dimension must be <= 2) rr<r|rr4 TypeError MemoryErrorrfrd)rtidxlengthrDrrrrs zIndexMixin._asindicescCs&|j\}}t||d}||tdS)zReturn a copy of row i of the matrix, as a (1 x n) row vector. Args: i (integer): Row Returns: cupyx.scipy.sparse.spmatrix: Sparse matrix with single row rN)rmrrcrbrtrBrrrrrgetrow zIndexMixin.getrowcCs&|j\}}t||d}|td|S)zReturn a copy of column i of the matrix, as a (m x 1) column vector. Args: i (integer): Column Returns: cupyx.scipy.sparse.spmatrix: Sparse matrix with single column rN)rmrrgrbrrrrgetcolrzIndexMixin.getcolcCtNr]rtrvrwrrrra zIndexMixin._get_intXintcCrrrrrrrrerzIndexMixin._get_intXarraycCrrrrrrrrcrzIndexMixin._get_intXslicecCrrrrrrrrgrzIndexMixin._get_sliceXintcCrrrrrrrrirzIndexMixin._get_sliceXslicecCrrrrrrrrjrzIndexMixin._get_sliceXarraycCrrrrrrrrkrzIndexMixin._get_arrayXintcCrrrrrrrrl"rzIndexMixin._get_arrayXslicecCrrrrrrrrn%rzIndexMixin._get_columnXarraycCrrrrrrrrs(rzIndexMixin._get_arrayXarraycCrrrrtrvrwrDrrrry+rzIndexMixin._set_intXintcCrrrrrrrr.rzIndexMixin._set_arrayXarraycCs6tj||jd}t||\}}||||dS)Nr)rr<toarrayrrpr)rtrvrwrDrrrrr1sz"IndexMixin._set_arrayXarray_sparseN)__name__ __module__ __qualname____doc__rxrrr^rrrrarercrgrirjrkrlrnrsryrrrrrrrVWs,43   rVcCstr t|tjjSdS)NF)rXr_r[sparser)rrrr_try_is_scipy_spmatrix8srcCsFt|ttjtjfst|r|jdkr|jjdkr| St |}t|t rUt |dkr1|\}}nJt |dkrA|dt d}}n:t |dkrQt dt d}}n*tdt|}|dure|t d}}n|jdkrrt|t dfS|jdkr{| St|st|rtdt|}t|}|durt|}|durt|}||fS)a Parse index. Always return a tuple of the form (row, col). Valid type for row/col is integer, slice, or array of integers. Returns: resulting row & col indices : single integer, slice, or array of integers. If row & column indices are supplied explicitly, they are used as the major/minor indices. If only one index is supplied, the minor index is assumed to be all (e.g., [maj, :]). rbr rNzinvalid number of indiceszoIndexing with sparse matrices is not supported except boolean indexing where matrix and index are equal shapes.)r_rrrr0rrdrkindnonzero_eliminate_ellipsistuplelenrbrf_compatible_boolean_index_boolean_index_to_arrayr)rrvrwrbool_rowbool_colrrrr>sD        rcCs |tur tdtdfSt|ts|St|D] \}}|tur#|}nq|St|dkr4tdtdfSt|dkr\|dkrT|dturLtdtdfStd|dfS|dtdfSg}||ddD] }|turq||qf|t|}tdd|}|d|tdf|t|S)z6Process indices with Ellipsis. Returns modified index.Nr rr)Ellipsisrbr_r enumeraterappendmax)rrCvfirst_ellipsistailndnslicerrrrvs4      "rcCs6|| ks ||krtd|||dkr||7}|S)Nz{} ({}) out of ranger)rfformat)rDdimnamerrrrs rrcCsZ|dkrdSzt|dkr|dnd}Wn tyYdSwt|tr&dSt||dS)zQReturns True if first element of the incompatible array type is boolean. r NrT)rrr__bool_scalar_types_first_element_bool)rmax_dimfirstrrrrs  rcCs8t|dr|jjdkr |SdSt|rtj|ddSdS)ztReturns a boolean index array that can be converted to integer array. Returns None if no such array exists. rdrr:rN)hasattrrrrrr<rrrrrs  rcCs0|jdkr tdtj||jd}t|dS)Nr zinvalid index shaperr)rdrfrarrayrwhererrrrrs r)r)r),r __future__rrrcupyx.scipy.sparse._baserr cupy.cudarrr0 scipy.sparser[rX ImportErrorr integerint_r`r:bool_rElementwiseKernel_compress_getitem_kern_compress_getitem_complex_kernrr$r(r-r'rK_insert_many_populate_arraysrArTrOrVrrrrrrrrrrrs          X_ b8$