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)
