o iFX@s dZddlZddlZddlmZddlmZddl m Z m Z ddl m Z ddlmZdd lmZdd lmZd d Zd dZddZddZd1ddZddddZddZddZddZdd Zd!d"Zd#d$Z d2d%d&Z!d3d'd(Z"d)d*Z#d+d,Z$d-d.Z%d/d0Z&dS)4zBA collection of utilities to work with sparse matrices and arrays.N)LinearOperator)_sparse_min_max_sparse_nan_min_max)_check_sample_weight)csc_mean_variance_axis0)csr_mean_variance_axis0)incr_mean_variance_axis0cCs(t|r|jnt|}d|}t|)z2Raises a TypeError if X is not a CSR or CSC matrixz,Expected a CSR or CSC sparse matrix, got %s.)spissparseformattype TypeError)XZ input_typeerrrh/var/www/html/eduruby.in/lip-sync/lip-sync-env/lib/python3.10/site-packages/sklearn/utils/sparsefuncs.py_raise_typeerrorsrcCs|dvr td|dS)N)rrz8Unknown axis value: %d. Use 0 for rows, or 1 for columns) ValueErroraxisrrr_raise_error_wrong_axis s rcCs6|jd|jdks J|j|j|jdd9_dS)aInplace column scaling of a CSR matrix. Scale each feature of the data matrix by multiplying with specific scale provided by the caller assuming a (n_samples, n_features) shape. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Matrix to normalize using the variance of the features. It should be of CSR format. scale : ndarray of shape (n_features,), dtype={np.float32, np.float64} Array of precomputed feature-wise values to use for scaling. Examples -------- >>> from sklearn.utils import sparsefuncs >>> from scipy import sparse >>> import numpy as np >>> indptr = np.array([0, 3, 4, 4, 4]) >>> indices = np.array([0, 1, 2, 2]) >>> data = np.array([8, 1, 2, 5]) >>> scale = np.array([2, 3, 2]) >>> csr = sparse.csr_matrix((data, indices, indptr)) >>> csr.todense() matrix([[8, 1, 2], [0, 0, 5], [0, 0, 0], [0, 0, 0]]) >>> sparsefuncs.inplace_csr_column_scale(csr, scale) >>> csr.todense() matrix([[16, 3, 4], [ 0, 0, 10], [ 0, 0, 0], [ 0, 0, 0]]) rrZclip)modeN)shapedataZtakeindicesrscalerrrinplace_csr_column_scale's%rcCs:|jd|jdks J|jt|t|j9_dS)aInplace row scaling of a CSR matrix. Scale each sample of the data matrix by multiplying with specific scale provided by the caller assuming a (n_samples, n_features) shape. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Matrix to be scaled. It should be of CSR format. scale : ndarray of float of shape (n_samples,) Array of precomputed sample-wise values to use for scaling. rN)rrnprepeatdiffindptrrrrrinplace_csr_row_scalePs"r$FcCst|t|r!|jdkr!|dkrt|||dSt|j||dSt|r>|jdkr>|dkr6t|||dSt|j||dSt|dS)a{Compute mean and variance along an axis on a CSR or CSC matrix. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Input data. It can be of CSR or CSC format. axis : {0, 1} Axis along which the axis should be computed. weights : ndarray of shape (n_samples,) or (n_features,), default=None If axis is set to 0 shape is (n_samples,) or if axis is set to 1 shape is (n_features,). If it is set to None, then samples are equally weighted. .. versionadded:: 0.24 return_sum_weights : bool, default=False If True, returns the sum of weights seen for each feature if `axis=0` or each sample if `axis=1`. .. versionadded:: 0.24 Returns ------- means : ndarray of shape (n_features,), dtype=floating Feature-wise means. variances : ndarray of shape (n_features,), dtype=floating Feature-wise variances. sum_weights : ndarray of shape (n_features,), dtype=floating Returned if `return_sum_weights` is `True`. Examples -------- >>> from sklearn.utils import sparsefuncs >>> from scipy import sparse >>> import numpy as np >>> indptr = np.array([0, 3, 4, 4, 4]) >>> indices = np.array([0, 1, 2, 2]) >>> data = np.array([8, 1, 2, 5]) >>> scale = np.array([2, 3, 2]) >>> csr = sparse.csr_matrix((data, indices, indptr)) >>> csr.todense() matrix([[8, 1, 2], [0, 0, 5], [0, 0, 0], [0, 0, 0]]) >>> sparsefuncs.mean_variance_axis(csr, axis=0) (array([2. , 0.25, 1.75]), array([12. , 0.1875, 4.1875])) csrr)weightsreturn_sum_weightscscN)rr r r _csr_mean_var_axis0_csc_mean_var_axis0Tr)rrr&r'rrrmean_variance_axisbs$6 r,)r&cCs.t|t|r|jdvst|t|dkr#tj|j||j d}t|t|kr9t|ks>t dt d|dkr^t||jdkr]t d|jddt|dnt||jdkryt d |jddt|d|dkr|j n|}|d urt |||j d}t |||||d S) a Compute incremental mean and variance along an axis on a CSR or CSC matrix. last_mean, last_var are the statistics computed at the last step by this function. Both must be initialized to 0-arrays of the proper size, i.e. the number of features in X. last_n is the number of samples encountered until now. Parameters ---------- X : CSR or CSC sparse matrix of shape (n_samples, n_features) Input data. axis : {0, 1} Axis along which the axis should be computed. last_mean : ndarray of shape (n_features,) or (n_samples,), dtype=floating Array of means to update with the new data X. Should be of shape (n_features,) if axis=0 or (n_samples,) if axis=1. last_var : ndarray of shape (n_features,) or (n_samples,), dtype=floating Array of variances to update with the new data X. Should be of shape (n_features,) if axis=0 or (n_samples,) if axis=1. last_n : float or ndarray of shape (n_features,) or (n_samples,), dtype=floating Sum of the weights seen so far, excluding the current weights If not float, it should be of shape (n_features,) if axis=0 or (n_samples,) if axis=1. If float it corresponds to having same weights for all samples (or features). weights : ndarray of shape (n_samples,) or (n_features,), default=None If axis is set to 0 shape is (n_samples,) or if axis is set to 1 shape is (n_features,). If it is set to None, then samples are equally weighted. .. versionadded:: 0.24 Returns ------- means : ndarray of shape (n_features,) or (n_samples,), dtype=floating Updated feature-wise means if axis = 0 or sample-wise means if axis = 1. variances : ndarray of shape (n_features,) or (n_samples,), dtype=floating Updated feature-wise variances if axis = 0 or sample-wise variances if axis = 1. n : ndarray of shape (n_features,) or (n_samples,), dtype=integral Updated number of seen samples per feature if axis=0 or number of seen features per sample if axis=1. If weights is not None, n is a sum of the weights of the seen samples or features instead of the actual number of seen samples or features. Notes ----- NaNs are ignored in the algorithm. Examples -------- >>> from sklearn.utils import sparsefuncs >>> from scipy import sparse >>> import numpy as np >>> indptr = np.array([0, 3, 4, 4, 4]) >>> indices = np.array([0, 1, 2, 2]) >>> data = np.array([8, 1, 2, 5]) >>> scale = np.array([2, 3, 2]) >>> csr = sparse.csr_matrix((data, indices, indptr)) >>> csr.todense() matrix([[8, 1, 2], [0, 0, 5], [0, 0, 0], [0, 0, 0]]) >>> sparsefuncs.incr_mean_variance_axis( ... csr, axis=0, last_mean=np.zeros(3), last_var=np.zeros(3), last_n=2 ... ) (array([1.33, 0.167, 1.17]), array([8.88, 0.139, 3.47]), array([6., 6., 6.])) )r(r%r)dtypez8last_mean, last_var, last_n do not have the same shapes.rzHIf axis=1, then last_mean, last_n, last_var should be of size n_samples z (Got z).zIIf axis=0, then last_mean, last_n, last_var should be of size n_features N) last_meanlast_varlast_nr&)rr r r rr sizefullrr-rr+r_incr_mean_var_axis0)rrr.r/r0r&rrrincr_mean_variance_axissBQ$ r4cCRt|r|jdkrt|j|dSt|r#|jdkr#t||dSt|dS)aInplace column scaling of a CSC/CSR matrix. Scale each feature of the data matrix by multiplying with specific scale provided by the caller assuming a (n_samples, n_features) shape. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Matrix to normalize using the variance of the features. It should be of CSC or CSR format. scale : ndarray of shape (n_features,), dtype={np.float32, np.float64} Array of precomputed feature-wise values to use for scaling. Examples -------- >>> from sklearn.utils import sparsefuncs >>> from scipy import sparse >>> import numpy as np >>> indptr = np.array([0, 3, 4, 4, 4]) >>> indices = np.array([0, 1, 2, 2]) >>> data = np.array([8, 1, 2, 5]) >>> scale = np.array([2, 3, 2]) >>> csr = sparse.csr_matrix((data, indices, indptr)) >>> csr.todense() matrix([[8, 1, 2], [0, 0, 5], [0, 0, 0], [0, 0, 0]]) >>> sparsefuncs.inplace_column_scale(csr, scale) >>> csr.todense() matrix([[16, 3, 4], [ 0, 0, 10], [ 0, 0, 0], [ 0, 0, 0]]) r(r%N)r r r r$r+rrrrrrinplace_column_scale#s % r6cCr5)aInplace row scaling of a CSR or CSC matrix. Scale each row of the data matrix by multiplying with specific scale provided by the caller assuming a (n_samples, n_features) shape. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Matrix to be scaled. It should be of CSR or CSC format. scale : ndarray of shape (n_features,), dtype={np.float32, np.float64} Array of precomputed sample-wise values to use for scaling. Examples -------- >>> from sklearn.utils import sparsefuncs >>> from scipy import sparse >>> import numpy as np >>> indptr = np.array([0, 2, 3, 4, 5]) >>> indices = np.array([0, 1, 2, 3, 3]) >>> data = np.array([8, 1, 2, 5, 6]) >>> scale = np.array([2, 3, 4, 5]) >>> csr = sparse.csr_matrix((data, indices, indptr)) >>> csr.todense() matrix([[8, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 5], [0, 0, 0, 6]]) >>> sparsefuncs.inplace_row_scale(csr, scale) >>> csr.todense() matrix([[16, 2, 0, 0], [ 0, 0, 6, 0], [ 0, 0, 0, 20], [ 0, 0, 0, 30]]) r(r%N)r r r rr+r$rrrrrinplace_row_scalePs $ r7cCsv||fD] }t|tjrtdq|dkr||jd7}|dkr'||jd7}|j|k}||j|j|k<||j|<dS)aKSwap two rows of a CSC matrix in-place. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Matrix whose two rows are to be swapped. It should be of CSC format. m : int Index of the row of X to be swapped. n : int Index of the row of X to be swapped. m and n should be valid integersrN) isinstancer ndarrayrrr)rmntZm_maskrrrinplace_swap_row_csc|s   r>c Csx||fD] }t|tjrtdq|dkr||jd7}|dkr'||jd7}||kr0||}}|j}||}||d}||}||d}||} ||} | | krr|j|d|| | 7<|| |j|d<|| |j|<t|jd||j|||j|||j|||j|dg|_t|jd||j|||j|||j|||j|dg|_dS)aKSwap two rows of a CSR matrix in-place. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Matrix whose two rows are to be swapped. It should be of CSR format. m : int Index of the row of X to be swapped. n : int Index of the row of X to be swapped. r8rrrN) r9r r:rrr#Z concatenaterr) rr;r<r=r#Zm_startZm_stopZn_startZn_stopZnz_mZnz_nrrrinplace_swap_row_csrsJ                r?cCsTt|r|jdkrt|||dSt|r$|jdkr$t|||dSt|dS)a Swap two rows of a CSC/CSR matrix in-place. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Matrix whose two rows are to be swapped. It should be of CSR or CSC format. m : int Index of the row of X to be swapped. n : int Index of the row of X to be swapped. Examples -------- >>> from sklearn.utils import sparsefuncs >>> from scipy import sparse >>> import numpy as np >>> indptr = np.array([0, 2, 3, 3, 3]) >>> indices = np.array([0, 2, 2]) >>> data = np.array([8, 2, 5]) >>> csr = sparse.csr_matrix((data, indices, indptr)) >>> csr.todense() matrix([[8, 0, 2], [0, 0, 5], [0, 0, 0], [0, 0, 0]]) >>> sparsefuncs.inplace_swap_row(csr, 0, 1) >>> csr.todense() matrix([[0, 0, 5], [8, 0, 2], [0, 0, 0], [0, 0, 0]]) r(r%N)r r r r>r?rrr;r<rrrinplace_swap_rows % rAcCs|dkr ||jd7}|dkr||jd7}t|r(|jdkr(t|||dSt|r:|jdkr:t|||dSt|dS)a Swap two columns of a CSC/CSR matrix in-place. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Matrix whose two columns are to be swapped. It should be of CSR or CSC format. m : int Index of the column of X to be swapped. n : int Index of the column of X to be swapped. Examples -------- >>> from sklearn.utils import sparsefuncs >>> from scipy import sparse >>> import numpy as np >>> indptr = np.array([0, 2, 3, 3, 3]) >>> indices = np.array([0, 2, 2]) >>> data = np.array([8, 2, 5]) >>> csr = sparse.csr_matrix((data, indices, indptr)) >>> csr.todense() matrix([[8, 0, 2], [0, 0, 5], [0, 0, 0], [0, 0, 0]]) >>> sparsefuncs.inplace_swap_column(csr, 0, 1) >>> csr.todense() matrix([[0, 8, 2], [0, 0, 5], [0, 0, 0], [0, 0, 0]]) rrr(r%N)rr r r r?r>rr@rrrinplace_swap_columns% rBcCs<t|r|jdvr|rt||dSt||dSt|dS)aCompute minimum and maximum along an axis on a CSR or CSC matrix. Optionally ignore NaN values. Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Input data. It should be of CSR or CSC format. axis : {0, 1} Axis along which the axis should be computed. ignore_nan : bool, default=False Ignore or passing through NaN values. .. versionadded:: 0.20 Returns ------- mins : ndarray of shape (n_features,), dtype={np.float32, np.float64} Feature-wise minima. maxs : ndarray of shape (n_features,), dtype={np.float32, np.float64} Feature-wise maxima. )r%r(rN)r r r rrr)rrZ ignore_nanrrr min_max_axis6s    rCcCs|dkrd}n|dkrd}n |jdkrtd|j|dur0|dur&|jStt|j|S|dkrGt|j}|durC|dS||S|dkrp|durZtj|j |j dd St |t|j}tj|j |j d|d St d |) aA variant of X.getnnz() with extension to weighting on axis 0. Useful in efficiently calculating multilabel metrics. Parameters ---------- X : sparse matrix of shape (n_samples, n_labels) Input data. It should be of CSR format. axis : {0, 1}, default=None The axis on which the data is aggregated. sample_weight : array-like of shape (n_samples,), default=None Weight for each row of X. Returns ------- nnz : int, float, ndarray of shape (n_samples,) or ndarray of shape (n_features,) Number of non-zero values in the array along a given axis. Otherwise, the total number of non-zero values in the array is returned. rrr%z#Expected CSR sparse format, got {0}NZintp) minlength)rFr&zUnsupported axis: {0}) r rZnnzr dotr"r#ZastypeZbincountrrr!r)rrZ sample_weightoutr&rrr count_nonzeroZs*   rIcCspt||}|s tjSt|dk}t|d\}}||r&t||||St|d|||t||||dS)zCompute the median of data with n_zeros additional zeros. This function is used to support sparse matrices; it modifies data in-place. rrrg@)lenr nanrIdivmodsort_get_elem_at_rank)rn_zerosZn_elems n_negativemiddleZis_oddrrr _get_medians  rRcCs,||kr||S|||krdS|||S)z@Find the value in data augmented with n_zeros for the given rankrr)ZrankrrPrOrrrrNs   rNc Cst|r |jdkstd|j|j}|j\}}t|}tt |D]\}\}}t |j ||}||j } t|| ||<q%|S)aCFind the median across axis 0 of a CSC matrix. It is equivalent to doing np.median(X, axis=0). Parameters ---------- X : sparse matrix of shape (n_samples, n_features) Input data. It should be of CSC format. Returns ------- median : ndarray of shape (n_features,) Median. r(z%Expected matrix of CSC format, got %s)r r r rr#rr Zzeros enumerate itertoolspairwisecopyrr1rR) rr#Z n_samplesZ n_featuresZmedianZf_indstartendrZnzrrrcsc_median_axis_0s   rYcsVdddfjtfddfddfddfddjjdS)aACreate an implicitly offset linear operator. This is used by PCA on sparse data to avoid densifying the whole data matrix. Params ------ X : sparse matrix of shape (n_samples, n_features) offset : ndarray of shape (n_features,) Returns ------- centered : LinearOperator Nc||SNrxroffsetrrz)_implicit_column_offset..crZr[rr\r^rrr`racs||Sr[)sumr\XTr_rrr`scs&|j|jdddddfS)Nrr)r+rbr\rcrrr`s&)ZmatvecZmatmatZrmatvecZrmatmatr-r)r+rr-rr^r)rrdr_r_implicit_column_offsets    re)NF)F)NN)'__doc__rTnumpyr Z scipy.sparsesparser Zscipy.sparse.linalgrZ utils.fixesrrZutils.validationrZsparsefuncs_fastrr*r r)r r3rrrr$r,r4r6r7r>r?rArBrCrIrRrNrYrerrrrs8      ) Ns-,?- 1 $6