def kronsum(A, B, format=None): """Kronecker sum of sparse matrices A and B. Kronecker sum is the sum of two Kronecker products ``kron(I_n, A) + kron(B, I_m)``, where ``I_n`` and ``I_m`` are identity matrices. Args: A (cupyx.scipy.sparse.spmatrix): a sparse matrix. B (cupyx.scipy.sparse.spmatrix): a sparse matrix. format (str): the format of the returned sparse matrix. Returns: cupyx.scipy.sparse.spmatrix: Generated sparse matrix with the specified ``format``. .. seealso:: :func:`scipy.sparse.kronsum` """ A = coo.coo_matrix(A) B = coo.coo_matrix(B) if A.shape[0] != A.shape[1]: raise ValueError('A is not square matrix') if B.shape[0] != B.shape[1]: raise ValueError('B is not square matrix') dtype = sputils.upcast(A.dtype, B.dtype) L = kron(eye(B.shape[0], dtype=dtype), A, format=format) R = kron(B, eye(A.shape[0], dtype=dtype), format=format) return (L + R).asformat(format)
def _min_or_max_axis(self, axis, min_or_max, explicit): N = self.shape[axis] if N == 0: raise ValueError("zero-size array to reduction operation") M = self.shape[1 - axis] mat = self.tocsc() if axis == 0 else self.tocsr() mat.sum_duplicates() # Do the reduction value = mat._minor_reduce(min_or_max, axis, explicit) major_index = cupy.arange(M) mask = value != 0 major_index = cupy.compress(mask, major_index) value = cupy.compress(mask, value) if axis == 0: return coo.coo_matrix( (value, (cupy.zeros(len(value)), major_index)), dtype=self.dtype, shape=(1, M)) else: return coo.coo_matrix( (value, (major_index, cupy.zeros(len(value)))), dtype=self.dtype, shape=(M, 1))
def kron(A, B, format=None): """Kronecker product of sparse matrices A and B. Args: A (cupyx.scipy.sparse.spmatrix): a sparse matrix. B (cupyx.scipy.sparse.spmatrix): a sparse matrix. format (str): the format of the returned sparse matrix. Returns: cupyx.scipy.sparse.spmatrix: Generated sparse matrix with the specified ``format``. .. seealso:: :func:`scipy.sparse.kron` """ # TODO(leofang): support BSR format when it's added to CuPy # TODO(leofang): investigate if possible to optimize performance by # starting with CSR instead of COO matrices A = coo.coo_matrix(A) B = coo.coo_matrix(B) out_shape = (A.shape[0] * B.shape[0], A.shape[1] * B.shape[1]) if A.nnz == 0 or B.nnz == 0: # kronecker product is the zero matrix return coo.coo_matrix(out_shape).asformat(format) if max(out_shape[0], out_shape[1]) > cupy.iinfo('int32').max: dtype = cupy.int64 else: dtype = cupy.int32 # expand entries of A into blocks row = A.row.astype(dtype, copy=True) * B.shape[0] row = row.repeat(B.nnz) col = A.col.astype(dtype, copy=True) * B.shape[1] col = col.repeat(B.nnz) data = A.data.repeat(B.nnz) # data's dtype follows that of A in SciPy # increment block indices row, col = row.reshape(-1, B.nnz), col.reshape(-1, B.nnz) row += B.row col += B.col row, col = row.ravel(), col.ravel() # compute block entries data = data.reshape(-1, B.nnz) * B.data data = data.ravel() return coo.coo_matrix((data, (row, col)), shape=out_shape).asformat(format)
def mst_gpu(d): import numpy as np import cugraph import cudf import cupy as cp from cupyx.scipy.sparse.csr import csr_matrix as csr_cupy from cupyx.scipy.sparse.coo import coo_matrix from cugraph.tree.minimum_spanning_tree_wrapper import mst_double, mst_float import scipy csr_gpu = csr_cupy(d) offsets = cudf.Series(csr_gpu.indptr) indices = cudf.Series(csr_gpu.indices) num_verts = csr_gpu.shape[0] num_edges = len(csr_gpu.indices) weights = cudf.Series(csr_gpu.data) if weights.dtype == np.float32: mst = mst_float(num_verts, num_edges, offsets, indices, weights) else: mst = mst_double(num_verts, num_edges, offsets, indices, weights) mst = csr_cupy( coo_matrix( (mst.weight.values, (mst.src.values, mst.dst.values)), shape=(num_verts, num_verts), )).get() return csr_cupy(scipy.sparse.triu(mst))
def random(m, n, density=0.01, format='coo', dtype=None, random_state=None, data_rvs=None): """Generates a random sparse matrix. This function generates a random sparse matrix. First it selects non-zero elements with given density ``density`` from ``(m, n)`` elements. So the number of non-zero elements ``k`` is ``k = m * n * density``. Value of each element is selected with ``data_rvs`` function. Args: m (int): Number of rows. n (int): Number of cols. density (float): Ratio of non-zero entries. format (str): Matrix format. dtype (~cupy.dtype): Type of the returned matrix values. random_state (cupy.random.RandomState or int): State of random number generator. If an integer is given, the method makes a new state for random number generator and uses it. If it is not given, the default state is used. This state is used to generate random indexes for nonzero entries. data_rvs (callable): A function to generate data for a random matrix. If it is not given, `random_state.rand` is used. Returns: cupyx.scipy.sparse.spmatrix: Generated matrix. .. seealso:: :func:`scipy.sparse.random` """ if density < 0 or density > 1: raise ValueError('density expected to be 0 <= density <= 1') dtype = cupy.dtype(dtype) if dtype.char not in 'fd': raise NotImplementedError('type %s not supported' % dtype) mn = m * n k = int(density * m * n) if random_state is None: random_state = cupy.random elif isinstance(random_state, (int, cupy.integer)): random_state = cupy.random.RandomState(random_state) if data_rvs is None: data_rvs = random_state.rand ind = random_state.choice(mn, size=k, replace=False) j = cupy.floor(ind * (1. / m)).astype('i') i = ind - j * m vals = data_rvs(k).astype(dtype) return coo.coo_matrix((vals, (i, j)), shape=(m, n)).asformat(format)
def eye(m, n=None, k=0, dtype='d', format=None): """Creates a sparse matrix with ones on diagonal. Args: m (int): Number of rows. n (int or None): Number of columns. If it is ``None``, it makes a square matrix. k (int): Diagonal to place ones on. dtype: Type of a matrix to create. format (str or None): Format of the result, e.g. ``format="csr"``. Returns: cupyx.scipy.sparse.spmatrix: Created sparse matrix. .. seealso:: :func:`scipy.sparse.eye` """ if n is None: n = m m, n = int(m), int(n) if m == n and k == 0: if format in ['csr', 'csc']: indptr = cupy.arange(n + 1, dtype='i') indices = cupy.arange(n, dtype='i') data = cupy.ones(n, dtype=dtype) if format == 'csr': cls = csr.csr_matrix else: cls = csc.csc_matrix return cls((data, indices, indptr), (n, n)) elif format == 'coo': row = cupy.arange(n, dtype='i') col = cupy.arange(n, dtype='i') data = cupy.ones(n, dtype=dtype) return coo.coo_matrix((data, (row, col)), (n, n)) diags = cupy.ones((1, max(0, min(m + k, n))), dtype=dtype) return spdiags(diags, k, m, n).asformat(format)
def __init__(self, arg1, shape=None, dtype=None, copy=False): if shape is not None: if not _util.isshape(shape): raise ValueError('invalid shape (must be a 2-tuple of int)') shape = int(shape[0]), int(shape[1]) if base.issparse(arg1): x = arg1.asformat(self.format) data = x.data indices = x.indices indptr = x.indptr if arg1.format != self.format: # When formats are differnent, all arrays are already copied copy = False if shape is None: shape = arg1.shape elif _util.isshape(arg1): m, n = arg1 m, n = int(m), int(n) data = basic.zeros(0, dtype if dtype else 'd') indices = basic.zeros(0, 'i') indptr = basic.zeros(self._swap(m, n)[0] + 1, dtype='i') # shape and copy argument is ignored shape = (m, n) copy = False elif scipy_available and scipy.sparse.issparse(arg1): # Convert scipy.sparse to cupyx.scipy.sparse x = arg1.asformat(self.format) data = cupy.array(x.data) indices = cupy.array(x.indices, dtype='i') indptr = cupy.array(x.indptr, dtype='i') copy = False if shape is None: shape = arg1.shape elif isinstance(arg1, tuple) and len(arg1) == 2: # Note: This implementation is not efficeint, as it first # constructs a sparse matrix with coo format, then converts it to # compressed format. sp_coo = coo.coo_matrix(arg1, shape=shape, dtype=dtype, copy=copy) sp_compressed = sp_coo.asformat(self.format) data = sp_compressed.data indices = sp_compressed.indices indptr = sp_compressed.indptr elif isinstance(arg1, tuple) and len(arg1) == 3: data, indices, indptr = arg1 if not (base.isdense(data) and data.ndim == 1 and base.isdense(indices) and indices.ndim == 1 and base.isdense(indptr) and indptr.ndim == 1): raise ValueError('data, indices, and indptr should be 1-D') if len(data) != len(indices): raise ValueError('indices and data should have the same size') elif base.isdense(arg1): if arg1.ndim > 2: raise TypeError('expected dimension <= 2 array or matrix') elif arg1.ndim == 1: arg1 = arg1[None] elif arg1.ndim == 0: arg1 = arg1[None, None] data, indices, indptr = self._convert_dense(arg1) copy = False if shape is None: shape = arg1.shape else: raise ValueError('Unsupported initializer format') if dtype is None: dtype = data.dtype else: dtype = numpy.dtype(dtype) if dtype.char not in '?fdFD': raise ValueError( 'Only bool, float32, float64, complex64 and complex128 ' 'are supported') data = data.astype(dtype, copy=copy) sparse_data._data_matrix.__init__(self, data) self.indices = indices.astype('i', copy=copy) self.indptr = indptr.astype('i', copy=copy) if shape is None: shape = self._swap(len(indptr) - 1, int(indices.max()) + 1) major, minor = self._swap(*shape) if len(indptr) != major + 1: raise ValueError('index pointer size (%d) should be (%d)' % (len(indptr), major + 1)) self._descr = cusparse.MatDescriptor.create() self._shape = shape
def bmat(blocks, format=None, dtype=None): """Builds a sparse matrix from sparse sub-blocks Args: blocks (array_like): Grid of sparse matrices with compatible shapes. An entry of None implies an all-zero matrix. format ({'bsr', 'coo', 'csc', 'csr', 'dia', 'dok', 'lil'}, optional): The sparse format of the result (e.g. "csr"). By default an appropriate sparse matrix format is returned. This choice is subject to change. dtype (dtype, optional): The data-type of the output matrix. If not given, the dtype is determined from that of `blocks`. Returns: bmat (sparse matrix) .. seealso:: :func:`scipy.sparse.bmat` Examples: >>> from cupy import array >>> from cupyx.scipy.sparse import csr_matrix, bmat >>> A = csr_matrix(array([[1., 2.], [3., 4.]])) >>> B = csr_matrix(array([[5.], [6.]])) >>> C = csr_matrix(array([[7.]])) >>> bmat([[A, B], [None, C]]).toarray() array([[1., 2., 5.], [3., 4., 6.], [0., 0., 7.]]) >>> bmat([[A, None], [None, C]]).toarray() array([[1., 2., 0.], [3., 4., 0.], [0., 0., 7.]]) """ # We assume here that blocks will be 2-D so we need to look, at most, # 2 layers deep for the shape # TODO(Corey J. Nolet): Check this assumption and raise ValueError # NOTE: We can't follow scipy exactly here # since we don't have an `object` datatype M = len(blocks) N = len(blocks[0]) blocks_flat = [] for m in range(M): for n in range(N): if blocks[m][n] is not None: blocks_flat.append(blocks[m][n]) if len(blocks_flat) == 0: return coo.coo_matrix((0, 0), dtype=dtype) # check for fast path cases if (N == 1 and format in (None, 'csr') and all(isinstance(b, csr.csr_matrix) for b in blocks_flat)): A = _compressed_sparse_stack(blocks_flat, 0) if dtype is not None: A = A.astype(dtype) return A elif (M == 1 and format in (None, 'csc') and all(isinstance(b, csc.csc_matrix) for b in blocks_flat)): A = _compressed_sparse_stack(blocks_flat, 1) if dtype is not None: A = A.astype(dtype) return A block_mask = numpy.zeros((M, N), dtype=bool) brow_lengths = numpy.zeros(M+1, dtype=numpy.int64) bcol_lengths = numpy.zeros(N+1, dtype=numpy.int64) # convert everything to COO format for i in range(M): for j in range(N): if blocks[i][j] is not None: A = coo.coo_matrix(blocks[i][j]) blocks[i][j] = A block_mask[i][j] = True if brow_lengths[i+1] == 0: brow_lengths[i+1] = A.shape[0] elif brow_lengths[i+1] != A.shape[0]: msg = ('blocks[{i},:] has incompatible row dimensions. ' 'Got blocks[{i},{j}].shape[0] == {got}, ' 'expected {exp}.'.format(i=i, j=j, exp=brow_lengths[i+1], got=A.shape[0])) raise ValueError(msg) if bcol_lengths[j+1] == 0: bcol_lengths[j+1] = A.shape[1] elif bcol_lengths[j+1] != A.shape[1]: msg = ('blocks[:,{j}] has incompatible row dimensions. ' 'Got blocks[{i},{j}].shape[1] == {got}, ' 'expected {exp}.'.format(i=i, j=j, exp=bcol_lengths[j+1], got=A.shape[1])) raise ValueError(msg) nnz = sum(block.nnz for block in blocks_flat) if dtype is None: all_dtypes = [blk.dtype for blk in blocks_flat] dtype = sputils.upcast(*all_dtypes) if all_dtypes else None row_offsets = numpy.cumsum(brow_lengths) col_offsets = numpy.cumsum(bcol_lengths) shape = (row_offsets[-1], col_offsets[-1]) data = cupy.empty(nnz, dtype=dtype) idx_dtype = sputils.get_index_dtype(maxval=max(shape)) row = cupy.empty(nnz, dtype=idx_dtype) col = cupy.empty(nnz, dtype=idx_dtype) nnz = 0 ii, jj = numpy.nonzero(block_mask) for i, j in zip(ii, jj): B = blocks[int(i)][int(j)] idx = slice(nnz, nnz + B.nnz) data[idx] = B.data row[idx] = B.row + row_offsets[i] col[idx] = B.col + col_offsets[j] nnz += B.nnz return coo.coo_matrix((data, (row, col)), shape=shape).asformat(format)