o 0 iZ@szdZddlZddlmZddlmZddlmZddlmZddlmZddl Z zddl Z dZ Wn e y;d Z Ynwee je jfZee jfZed d d d ZeddddZddZddZeddddZddZddZddZejd d!d"d#dd$Zejd%d&d'd(dd$Z d@d)d*Z ed+d,d-d.Z!Gd/d0d0e"Z#d1d2Z$d3d4Z%d5d6Z&d7d8Z'dAd:d;Z(dd?Z*dS)Bz*Indexing mixin for sparse matrix classes. N)_core) isspmatrix)spmatrix)device)runtimeTFzT d, S ind, int32 minorz raw T answerz+if (ind == minor) atomicAdd(&answer[0], d);Z#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); } Z+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) AxAjApstartstopZ start_offsetZ stop_offsetBpBjBxre/home/app/PaddleOCR-VL-test/.venv_paddleocr/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 rdtyperNout)cupyemptysizercumsum) r r r r rmaskZmask_sumrrrrrr_get_csr_submatrix_minor_axisDs   rzNint32 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]; Z$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 rrrNrr) rdiffrrrrr _csr_indptr_to_coo_rows_csr_row_index_ker) r r r rowsZrow_nnzrnnzout_rowsrrrrr_csr_row_indexqs    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)Zcupy_backends.cuda.libsr&rrnumpyZint32rZget_cusparse_handlerZis_hip ValueErrorZxcsr2coodataZptrrZCUSPARSE_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 lastrboolrr)rasarraystackZlexsortZastypeZonesr_unique_mask_kern) ijxZ idx_dtypeZstackedorderZindptr_insertsZindices_insertsZ data_insertsrrrr_select_last_indicess r4zqraw 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++; } Z1cupyx_scipy_sparse_csr_copy_existing_indices_kern)Z 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; } Z#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)Zn_rowZn_colr r r ZBirZ not_found_valrrr_csr_sample_values'sr6zWI 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; Z)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.0rzindex results in >2 dimensionsr'number of row and column indices differr) scipy_availabler'libZ 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_columnXarrayZravelrbroadcast_arraysr __class__Z atleast_2dr_get_arrayXarray)selfkeyrowcolrrr __getitem__ZsZ                       &   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) Nrrz&Trying to assign a sequence to an itemrr8zshape mismatch in assignmentT)rH)r>r?r@rr-rrr( _set_intXintZflatrBZarangeindicesrMZ atleast_1drDrOrFrZtocooZsum_duplicates_set_arrayXarray_sparseZreshape_set_arrayXarray) rRrSr2rTrUr0r1Z broadcast_rowZ broadcast_col_rrr __setitem__sV   $  "        zIndexMixin.__setitem__cCs.t|tjtjfr|jdkr|jdkrdSdS)NrrTF)r?rndarrayr'rDr)rRindexrrr _is_scalarszIndexMixin._is_scalarcCs|j\}}t|\}}||r|}||r|}t|tr)t||d}n t|ts4|||}t|trCt||d}||fSt|tsN|||}||fS)NrTcolumn) rM _unpack_indexr_itemr?r@_normalize_indexrB _asindices)rRrSMNrTrUrrrr>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)rzIndex dimension must be <= 2) rr-rXrr( TypeError MemoryErrorrFrD)rRidxlengthr2rrrrds 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 r^N)rMrcrCrBrRr0rerfrrrgetrow 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 r^N)rMrcrGrBrlrrrgetcolrnzIndexMixin.getcolcCtNr=rRrTrUrrrrA zIndexMixin._get_intXintcCrprqrrrsrrrrErtzIndexMixin._get_intXarraycCrprqrrrsrrrrCrtzIndexMixin._get_intXslicecCrprqrrrsrrrrGrtzIndexMixin._get_sliceXintcCrprqrrrsrrrrIrtzIndexMixin._get_sliceXslicecCrprqrrrsrrrrJrtzIndexMixin._get_sliceXarraycCrprqrrrsrrrrKrtzIndexMixin._get_arrayXintcCrprqrrrsrrrrL rtzIndexMixin._get_arrayXslicecCrprqrrrsrrrrN#rtzIndexMixin._get_columnXarraycCrprqrrrsrrrrQ&rtzIndexMixin._get_arrayXarraycCrprqrrrRrTrUr2rrrrW)rtzIndexMixin._set_intXintcCrprqrrrurrrrZ,rtzIndexMixin._set_arrayXarraycCs6tj||jd}t||\}}||||dS)Nr)rr-ZtoarrayrrOrZ)rRrTrUr2r[rrrrY/sz"IndexMixin._set_arrayXarray_sparseN)__name__ __module__ __qualname____doc__rVr\r_r>rdrmrorArErCrGrIrJrKrLrNrQrWrZrYrrrrr7Us,43   r7cCstr t|tjjSdS)NF)r9r?r;sparser)r^rrr_try_is_scipy_spmatrix6sr{cCs&t|ttjtjfst|r|jdkr|jjdkr| St |}t|t rEt |dkr1|\}}n:t |dkrA|dt d}}n*tdt|}|durU|t d}}n|jdkrbt|t dfS|jdkrk| St|sst|rwtdt|}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, :]). rgbrrNzinvalid number of indiceszoIndexing with sparse matrices is not supported except boolean indexing where matrix and index are equal shapes.)r?rrr]r'r{rDrkindZnonzero_eliminate_ellipsistuplelenrBrF_compatible_boolean_index_boolean_index_to_arrayr)r^rTrUrjZbool_rowZbool_colrrrra<s@       racCs |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.Nrrgr)EllipsisrBr?r enumeraterappendmax)r^r1vZfirst_ellipsistailndZnslicerrrr~rs4      "r~cCs6|| ks ||krtd|||dkr||7}|S)Nz{} ({}) out of ranger)rFformat)r2dimnamerrrrcs rcrgcCsZ|dkrdSzt|dkr|dnd}Wn tyYdSwt|tr&dSt||dS)zQReturns True if first element of the incompatible array type is boolean. rNrT)rrhr?_bool_scalar_types_first_element_bool)rjZmax_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. rDr|r+rN)hasattrrr}rrr-rjrrrrs  rcCs0|jdkr tdtj||jd}t|dS)Nrzinvalid index shaperr)rDrFrarrayrwhererrrrrs r)r)rg)+ryrrZcupyx.scipy.sparse._baserrZ cupy.cudarrr'Z scipy.sparser;r9 ImportErrorr integerint_r@r+Zbool_rZElementwiseKernelZ_compress_getitem_kernZ_compress_getitem_complex_kernrrr!r%r r4Z_insert_many_populate_arraysr/r6r5objectr7r{rar~rcrrrrrrrs         X_ b6$