def connected_components(csgraph,
directed=True,
connection='weak',
return_labels=True):
"""Analyzes the connected components of a sparse graph
Args:
csgraph (cupy.ndarray of cupyx.scipy.sparse.csr_matrix): The adjacency
matrix representing connectivity among nodes.
directed (bool): If ``True``, it operates on a directed graph. If
``False``, it operates on an undirected graph.
connection (str): ``'weak'`` or ``'strong'``. For directed graphs, the
type of connection to use. Nodes i and j are "strongly" connected
only when a path exists both from i to j and from j to i.
If ``directed`` is ``False``, this argument is ignored.
return_labels (bool): If ``True``, it returns the labels for each of
the connected components.
Returns:
tuple of int and cupy.ndarray, or int:
If ``return_labels`` == ``True``, returns a tuple ``(n, labels)``,
where ``n`` is the number of connected components and ``labels`` is
labels of each connected components. Otherwise, returns ``n``.
.. seealso:: :func:`scipy.sparse.csgraph.connected_components`
"""
if not _cugraph_available:
raise RuntimeError('cugraph is not available')
connection = connection.lower()
if connection not in ('weak', 'strong'):
raise ValueError("connection must be 'weak' or 'strong'")
if not directed:
connection = 'weak'
if not cupyx.scipy.sparse.isspmatrix_csr(csgraph):
csgraph = cupyx.scipy.sparse.csr_matrix(csgraph)
_util._assert_nd_squareness(csgraph)
m = csgraph.shape[0]
if csgraph.nnz == 0:
return m, cupy.arange(m, dtype=csgraph.indices.dtype)
labels = cupy.empty(m, dtype=csgraph.indices.dtype)
if connection == 'strong':
cugraph.strongly_connected_components(csgraph, labels)
else:
csgraph += csgraph.T
if not cupyx.scipy.sparse.isspmatrix_csr(csgraph):
csgraph = cupyx.scipy.sparse.csr_matrix(csgraph)
cugraph.weakly_connected_components(csgraph, labels)
# Note: In the case of weak connection, cuGraph creates labels with a
# start number of 1, so decrement the label number.
labels -= 1
count = cupy.zeros((1, ), dtype=csgraph.indices.dtype)
root_labels = cupy.empty((m, ), dtype=csgraph.indices.dtype)
_cupy_count_components(labels, count, root_labels, size=m)
n = int(count[0])
if not return_labels:
return n
_cupy_adjust_labels(n, cupy.sort(root_labels[:n]), labels)
return n, labels
def _batched_inv(a):
assert(a.ndim >= 3)
_util._assert_cupy_array(a)
_util._assert_nd_squareness(a)
dtype, out_dtype = _util.linalg_common_type(a)
if dtype == cupy.float32:
getrf = cupy.cuda.cublas.sgetrfBatched
getri = cupy.cuda.cublas.sgetriBatched
elif dtype == cupy.float64:
getrf = cupy.cuda.cublas.dgetrfBatched
getri = cupy.cuda.cublas.dgetriBatched
elif dtype == cupy.complex64:
getrf = cupy.cuda.cublas.cgetrfBatched
getri = cupy.cuda.cublas.cgetriBatched
elif dtype == cupy.complex128:
getrf = cupy.cuda.cublas.zgetrfBatched
getri = cupy.cuda.cublas.zgetriBatched
else:
msg = ('dtype must be float32, float64, complex64 or complex128'
' (actual: {})'.format(a.dtype))
raise ValueError(msg)
if 0 in a.shape:
return cupy.empty_like(a, dtype=out_dtype)
a_shape = a.shape
# copy is necessary to present `a` to be overwritten.
a = a.astype(dtype, order='C').reshape(-1, a_shape[-2], a_shape[-1])
handle = device.get_cublas_handle()
batch_size = a.shape[0]
n = a.shape[1]
lda = n
step = n * lda * a.itemsize
start = a.data.ptr
stop = start + step * batch_size
a_array = cupy.arange(start, stop, step, dtype=cupy.uintp)
pivot_array = cupy.empty((batch_size, n), dtype=cupy.int32)
info_array = cupy.empty((batch_size,), dtype=cupy.int32)
getrf(handle, n, a_array.data.ptr, lda, pivot_array.data.ptr,
info_array.data.ptr, batch_size)
cupy.linalg._util._check_cublas_info_array_if_synchronization_allowed(
getrf, info_array)
c = cupy.empty_like(a)
ldc = lda
step = n * ldc * c.itemsize
start = c.data.ptr
stop = start + step * batch_size
c_array = cupy.arange(start, stop, step, dtype=cupy.uintp)
getri(handle, n, a_array.data.ptr, lda, pivot_array.data.ptr,
c_array.data.ptr, ldc, info_array.data.ptr, batch_size)
cupy.linalg._util._check_cublas_info_array_if_synchronization_allowed(
getri, info_array)
return c.reshape(a_shape).astype(out_dtype, copy=False)
def invh(a):
"""Compute the inverse of a Hermitian matrix.
This function computes a inverse of a real symmetric or complex hermitian
positive-definite matrix using Cholesky factorization. If matrix ``a`` is
not positive definite, Cholesky factorization fails and it raises an error.
Args:
a (cupy.ndarray): Real symmetric or complex hermitian maxtix.
Returns:
cupy.ndarray: The inverse of matrix ``a``.
"""
_util._assert_cupy_array(a)
_util._assert_nd_squareness(a)
# TODO: Remove this assert once cusolver supports nrhs > 1 for potrsBatched
_util._assert_rank2(a)
n = a.shape[-1]
identity_matrix = cupy.eye(n, dtype=a.dtype)
b = cupy.empty(a.shape, a.dtype)
b[...] = identity_matrix
return lapack.posv(a, b)
def cholesky(a):
"""Cholesky decomposition.
Decompose a given two-dimensional square matrix into ``L * L.T``,
where ``L`` is a lower-triangular matrix and ``.T`` is a conjugate
transpose operator.
Args:
a (cupy.ndarray): The input matrix with dimension ``(N, N)``
Returns:
cupy.ndarray: The lower-triangular matrix.
.. warning::
This function calls one or more cuSOLVER routine(s) which may yield
invalid results if input conditions are not met.
To detect these invalid results, you can set the `linalg`
configuration to a value that is not `ignore` in
:func:`cupyx.errstate` or :func:`cupyx.seterr`.
.. seealso:: :func:`numpy.linalg.cholesky`
"""
_util._assert_cupy_array(a)
_util._assert_nd_squareness(a)
if a.ndim > 2:
return _potrf_batched(a)
dtype, out_dtype = _util.linalg_common_type(a)
x = a.astype(dtype, order='C', copy=True)
n = len(a)
handle = device.get_cusolver_handle()
dev_info = cupy.empty(1, dtype=numpy.int32)
if dtype == 'f':
potrf = cusolver.spotrf
potrf_bufferSize = cusolver.spotrf_bufferSize
elif dtype == 'd':
potrf = cusolver.dpotrf
potrf_bufferSize = cusolver.dpotrf_bufferSize
elif dtype == 'F':
potrf = cusolver.cpotrf
potrf_bufferSize = cusolver.cpotrf_bufferSize
else: # dtype == 'D':
potrf = cusolver.zpotrf
potrf_bufferSize = cusolver.zpotrf_bufferSize
buffersize = potrf_bufferSize(
handle, cublas.CUBLAS_FILL_MODE_UPPER, n, x.data.ptr, n)
workspace = cupy.empty(buffersize, dtype=dtype)
potrf(
handle, cublas.CUBLAS_FILL_MODE_UPPER, n, x.data.ptr, n,
workspace.data.ptr, buffersize, dev_info.data.ptr)
cupy.linalg._util._check_cusolver_dev_info_if_synchronization_allowed(
potrf, dev_info)
_util._tril(x, k=0)
return x.astype(out_dtype, copy=False)
def lsqr(A, b):
"""Solves linear system with QR decomposition.
Find the solution to a large, sparse, linear system of equations.
The function solves ``Ax = b``. Given two-dimensional matrix ``A`` is
decomposed into ``Q * R``.
Args:
A (cupy.ndarray or cupyx.scipy.sparse.csr_matrix): The input matrix
with dimension ``(N, N)``
b (cupy.ndarray): Right-hand side vector.
Returns:
tuple:
Its length must be ten. It has same type elements
as SciPy. Only the first element, the solution vector ``x``, is
available and other elements are expressed as ``None`` because
the implementation of cuSOLVER is different from the one of SciPy.
You can easily calculate the fourth element by ``norm(b - Ax)``
and the ninth element by ``norm(x)``.
.. seealso:: :func:`scipy.sparse.linalg.lsqr`
"""
if not sparse.isspmatrix_csr(A):
A = sparse.csr_matrix(A)
_util._assert_nd_squareness(A)
_util._assert_cupy_array(b)
m = A.shape[0]
if b.ndim != 1 or len(b) != m:
raise ValueError('b must be 1-d array whose size is same as A')
# Cast to float32 or float64
if A.dtype == 'f' or A.dtype == 'd':
dtype = A.dtype
else:
dtype = numpy.promote_types(A.dtype, 'f')
handle = device.get_cusolver_sp_handle()
nnz = A.nnz
tol = 1.0
reorder = 1
x = cupy.empty(m, dtype=dtype)
singularity = numpy.empty(1, numpy.int32)
if dtype == 'f':
csrlsvqr = cusolver.scsrlsvqr
else:
csrlsvqr = cusolver.dcsrlsvqr
csrlsvqr(
handle, m, nnz, A._descr.descriptor, A.data.data.ptr,
A.indptr.data.ptr, A.indices.data.ptr, b.data.ptr, tol, reorder,
x.data.ptr, singularity.ctypes.data)
# The return type of SciPy is always float64. Therefore, x must be casted.
x = x.astype(numpy.float64)
ret = (x, None, None, None, None, None, None, None, None, None)
return ret
def solve(a, b):
"""Solves a linear matrix equation.
It computes the exact solution of ``x`` in ``ax = b``,
where ``a`` is a square and full rank matrix.
Args:
a (cupy.ndarray): The matrix with dimension ``(..., M, M)``.
b (cupy.ndarray): The matrix with dimension ``(...,M)`` or
``(..., M, K)``.
Returns:
cupy.ndarray:
The matrix with dimension ``(..., M)`` or ``(..., M, K)``.
.. warning::
This function calls one or more cuSOLVER routine(s) which may yield
invalid results if input conditions are not met.
To detect these invalid results, you can set the `linalg`
configuration to a value that is not `ignore` in
:func:`cupyx.errstate` or :func:`cupyx.seterr`.
.. seealso:: :func:`numpy.linalg.solve`
"""
if a.ndim > 2 and a.shape[-1] <= get_batched_gesv_limit():
# Note: There is a low performance issue in batched_gesv when matrix is
# large, so it is not used in such cases.
return batched_gesv(a, b)
_util._assert_cupy_array(a, b)
_util._assert_nd_squareness(a)
if not ((a.ndim == b.ndim or a.ndim == b.ndim + 1)
and a.shape[:-1] == b.shape[:a.ndim - 1]):
raise ValueError(
'a must have (..., M, M) shape and b must have (..., M) '
'or (..., M, K)')
dtype = numpy.promote_types(a.dtype, b.dtype)
dtype = numpy.promote_types(dtype, 'f')
if a.ndim == 2:
# prevent 'a' and 'b' to be overwritten
a = a.astype(dtype, copy=True, order='F')
b = b.astype(dtype, copy=True, order='F')
cupyx.lapack.gesv(a, b)
return b
# prevent 'a' to be overwritten
a = a.astype(dtype, copy=True, order='C')
x = cupy.empty_like(b)
shape = a.shape[:-2]
for i in range(numpy.prod(shape)):
index = numpy.unravel_index(i, shape)
# prevent 'b' to be overwritten
bi = b[index].astype(dtype, copy=True, order='F')
cupyx.lapack.gesv(a[index], bi)
x[index] = bi
return x
def lschol(A, b):
"""Solves linear system with cholesky decomposition.
Find the solution to a large, sparse, linear system of equations.
The function solves ``Ax = b``. Given two-dimensional matrix ``A`` is
decomposed into ``L * L^*``.
Args:
A (cupy.ndarray or cupyx.scipy.sparse.csr_matrix): The input matrix
with dimension ``(N, N)``. Must be positive-definite input matrix.
Only symmetric real matrix is supported currently.
b (cupy.ndarray): Right-hand side vector.
Returns:
ret (cupy.ndarray): The solution vector ``x``.
"""
if not sparse.isspmatrix_csr(A):
A = sparse.csr_matrix(A)
_util._assert_nd_squareness(A)
_util._assert_cupy_array(b)
m = A.shape[0]
if b.ndim != 1 or len(b) != m:
raise ValueError('b must be 1-d array whose size is same as A')
# Cast to float32 or float64
if A.dtype == 'f' or A.dtype == 'd':
dtype = A.dtype
else:
dtype = numpy.promote_types(A.dtype, 'f')
handle = device.get_cusolver_sp_handle()
nnz = A.nnz
tol = 1.0
reorder = 1
x = cupy.empty(m, dtype=dtype)
singularity = numpy.empty(1, numpy.int32)
if dtype == 'f':
csrlsvchol = cusolver.scsrlsvchol
else:
csrlsvchol = cusolver.dcsrlsvchol
csrlsvchol(
handle, m, nnz, A._descr.descriptor, A.data.data.ptr,
A.indptr.data.ptr, A.indices.data.ptr, b.data.ptr, tol, reorder,
x.data.ptr, singularity.ctypes.data)
# The return type of SciPy is always float64.
x = x.astype(numpy.float64)
return x
def inv(a):
"""Computes the inverse of a matrix.
This function computes matrix ``a_inv`` from n-dimensional regular matrix
``a`` such that ``dot(a, a_inv) == eye(n)``.
Args:
a (cupy.ndarray): The regular matrix
Returns:
cupy.ndarray: The inverse of a matrix.
.. warning::
This function calls one or more cuSOLVER routine(s) which may yield
invalid results if input conditions are not met.
To detect these invalid results, you can set the `linalg`
configuration to a value that is not `ignore` in
:func:`cupyx.errstate` or :func:`cupyx.seterr`.
.. seealso:: :func:`numpy.linalg.inv`
"""
if a.ndim >= 3:
return _batched_inv(a)
_util._assert_cupy_array(a)
_util._assert_rank2(a)
_util._assert_nd_squareness(a)
dtype, out_dtype = _util.linalg_common_type(a)
order = 'F' if a._f_contiguous else 'C'
# prevent 'a' to be overwritten
a = a.astype(dtype, copy=True, order=order)
b = cupy.eye(a.shape[0], dtype=dtype, order=order)
if order == 'F':
cupyx.lapack.gesv(a, b)
else:
cupyx.lapack.gesv(a.T, b.T)
return b.astype(out_dtype, copy=False)
def eigvalsh(a, UPLO='L'):
"""Calculates eigenvalues of a symmetric matrix.
This method calculates eigenvalues a given symmetric matrix.
Note that :func:`cupy.linalg.eigh` calculates both eigenvalues and
eigenvectors.
Args:
a (cupy.ndarray): A symmetric 2-D square matrix ``(M, M)`` or a batch
of symmetric 2-D square matrices ``(..., M, M)``.
UPLO (str): Select from ``'L'`` or ``'U'``. It specifies which
part of ``a`` is used. ``'L'`` uses the lower triangular part of
``a``, and ``'U'`` uses the upper triangular part of ``a``.
Returns:
cupy.ndarray:
Returns eigenvalues as a vector ``w``. For batch input,
``w[k]`` is a vector of eigenvalues of matrix ``a[k]``.
.. warning::
This function calls one or more cuSOLVER routine(s) which may yield
invalid results if input conditions are not met.
To detect these invalid results, you can set the `linalg`
configuration to a value that is not `ignore` in
:func:`cupyx.errstate` or :func:`cupyx.seterr`.
.. seealso:: :func:`numpy.linalg.eigvalsh`
"""
if a.ndim < 2:
raise ValueError('Array must be at least two-dimensional')
_util._assert_nd_squareness(a)
if a.ndim > 2:
return cupy.cusolver.syevj(a, UPLO, False)
else:
return _syevd(a, UPLO, False)[0]
def slogdet(a):
"""Returns sign and logarithm of the determinant of an array.
It calculates the natural logarithm of the determinant of a given value.
Args:
a (cupy.ndarray): The input matrix with dimension ``(..., N, N)``.
Returns:
tuple of :class:`~cupy.ndarray`:
It returns a tuple ``(sign, logdet)``. ``sign`` represents each
sign of the determinant as a real number ``0``, ``1`` or ``-1``.
'logdet' represents the natural logarithm of the absolute of the
determinant.
If the determinant is zero, ``sign`` will be ``0`` and ``logdet``
will be ``-inf``.
The shapes of both ``sign`` and ``logdet`` are equal to
``a.shape[:-2]``.
.. warning::
This function calls one or more cuSOLVER routine(s) which may yield
invalid results if input conditions are not met.
To detect these invalid results, you can set the `linalg`
configuration to a value that is not `ignore` in
:func:`cupyx.errstate` or :func:`cupyx.seterr`.
.. warning::
To produce the same results as :func:`numpy.linalg.slogdet` for
singular inputs, set the `linalg` configuration to `raise`.
.. seealso:: :func:`numpy.linalg.slogdet`
"""
if a.ndim < 2:
msg = ('%d-dimensional array given. '
'Array must be at least two-dimensional' % a.ndim)
raise linalg.LinAlgError(msg)
_util._assert_nd_squareness(a)
dtype = numpy.promote_types(a.dtype.char, 'f')
real_dtype = numpy.dtype(dtype.char.lower())
if dtype not in (numpy.float32, numpy.float64,
numpy.complex64, numpy.complex128):
msg = ('dtype must be float32, float64, complex64, or complex128'
' (actual: {})'.format(a.dtype))
raise ValueError(msg)
a_shape = a.shape
shape = a_shape[:-2]
n = a_shape[-2]
if a.size == 0:
# empty batch (result is empty, too) or empty matrices det([[]]) == 1
sign = cupy.ones(shape, dtype)
logdet = cupy.zeros(shape, real_dtype)
return sign, logdet
lu, ipiv, dev_info = _decomposition._lu_factor(a, dtype)
# dev_info < 0 means illegal value (in dimensions, strides, and etc.) that
# should never happen even if the matrix contains nan or inf.
# TODO(kataoka): assert dev_info >= 0 if synchronization is allowed for
# debugging purposes.
diag = cupy.diagonal(lu, axis1=-2, axis2=-1)
logdet = cupy.log(cupy.abs(diag)).sum(axis=-1)
# ipiv is 1-origin
non_zero = cupy.count_nonzero(ipiv != cupy.arange(1, n + 1), axis=-1)
if dtype.kind == "f":
non_zero += cupy.count_nonzero(diag < 0, axis=-1)
# Note: sign == -1 ** (non_zero % 2)
sign = (non_zero % 2) * -2 + 1
if dtype.kind == "c":
sign = sign * cupy.prod(diag / cupy.abs(diag), axis=-1)
singular = dev_info > 0
return (
cupy.where(singular, dtype.type(0), sign.astype(dtype)).reshape(shape),
cupy.where(singular, real_dtype.type('-inf'), logdet).reshape(shape),
)
def inv(a):
"""Computes the inverse of a matrix.
This function computes matrix ``a_inv`` from n-dimensional regular matrix
``a`` such that ``dot(a, a_inv) == eye(n)``.
Args:
a (cupy.ndarray): The regular matrix
Returns:
cupy.ndarray: The inverse of a matrix.
.. warning::
This function calls one or more cuSOLVER routine(s) which may yield
invalid results if input conditions are not met.
To detect these invalid results, you can set the `linalg`
configuration to a value that is not `ignore` in
:func:`cupyx.errstate` or :func:`cupyx.seterr`.
.. seealso:: :func:`numpy.linalg.inv`
"""
if a.ndim >= 3:
return _batched_inv(a)
# to prevent `a` to be overwritten
a = a.copy()
_util._assert_cupy_array(a)
_util._assert_rank2(a)
_util._assert_nd_squareness(a)
# support float32, float64, complex64, and complex128
if a.dtype.char in 'fdFD':
dtype = a.dtype.char
else:
dtype = numpy.promote_types(a.dtype.char, 'f')
cusolver_handle = device.get_cusolver_handle()
dev_info = cupy.empty(1, dtype=numpy.int32)
ipiv = cupy.empty((a.shape[0], 1), dtype=numpy.intc)
if dtype == 'f':
getrf = cusolver.sgetrf
getrf_bufferSize = cusolver.sgetrf_bufferSize
getrs = cusolver.sgetrs
elif dtype == 'd':
getrf = cusolver.dgetrf
getrf_bufferSize = cusolver.dgetrf_bufferSize
getrs = cusolver.dgetrs
elif dtype == 'F':
getrf = cusolver.cgetrf
getrf_bufferSize = cusolver.cgetrf_bufferSize
getrs = cusolver.cgetrs
elif dtype == 'D':
getrf = cusolver.zgetrf
getrf_bufferSize = cusolver.zgetrf_bufferSize
getrs = cusolver.zgetrs
else:
msg = ('dtype must be float32, float64, complex64 or complex128'
' (actual: {})'.format(a.dtype))
raise ValueError(msg)
m = a.shape[0]
buffersize = getrf_bufferSize(cusolver_handle, m, m, a.data.ptr, m)
workspace = cupy.empty(buffersize, dtype=dtype)
# LU factorization
getrf(cusolver_handle, m, m, a.data.ptr, m, workspace.data.ptr,
ipiv.data.ptr, dev_info.data.ptr)
cupy.linalg._util._check_cusolver_dev_info_if_synchronization_allowed(
getrf, dev_info)
b = cupy.eye(m, dtype=dtype)
# solve for the inverse
getrs(cusolver_handle, 0, m, m, a.data.ptr, m, ipiv.data.ptr, b.data.ptr,
m, dev_info.data.ptr)
cupy.linalg._util._check_cusolver_dev_info_if_synchronization_allowed(
getrs, dev_info)
return b
def invh(a):
"""Compute the inverse of a Hermitian matrix.
This function computes a inverse of a real symmetric or complex hermitian
positive-definite matrix using Cholesky factorization. If matrix ``a`` is
not positive definite, Cholesky factorization fails and it raises an error.
Args:
a (cupy.ndarray): Real symmetric or complex hermitian maxtix.
Returns:
cupy.ndarray: The inverse of matrix ``a``.
"""
_util._assert_cupy_array(a)
_util._assert_nd_squareness(a)
# TODO: Remove this assert once cusolver supports nrhs > 1 for potrsBatched
_util._assert_rank2(a)
if a.ndim > 2:
return _batched_invh(a)
# to prevent `a` from being overwritten
a = a.copy()
# support float32, float64, complex64, and complex128
if a.dtype.char in 'fdFD':
dtype = a.dtype.char
else:
dtype = numpy.promote_types(a.dtype.char, 'f').char
cusolver_handle = device.get_cusolver_handle()
dev_info = cupy.empty(1, dtype=numpy.int32)
if dtype == 'f':
potrf = cusolver.spotrf
potrf_bufferSize = cusolver.spotrf_bufferSize
potrs = cusolver.spotrs
elif dtype == 'd':
potrf = cusolver.dpotrf
potrf_bufferSize = cusolver.dpotrf_bufferSize
potrs = cusolver.dpotrs
elif dtype == 'F':
potrf = cusolver.cpotrf
potrf_bufferSize = cusolver.cpotrf_bufferSize
potrs = cusolver.cpotrs
elif dtype == 'D':
potrf = cusolver.zpotrf
potrf_bufferSize = cusolver.zpotrf_bufferSize
potrs = cusolver.zpotrs
else:
msg = ('dtype must be float32, float64, complex64 or complex128'
' (actual: {})'.format(a.dtype))
raise ValueError(msg)
m = a.shape[0]
uplo = cublas.CUBLAS_FILL_MODE_LOWER
worksize = potrf_bufferSize(cusolver_handle, uplo, m, a.data.ptr, m)
workspace = cupy.empty(worksize, dtype=dtype)
# Cholesky factorization
potrf(cusolver_handle, uplo, m, a.data.ptr, m, workspace.data.ptr,
worksize, dev_info.data.ptr)
info = dev_info[0]
if info != 0:
if info < 0:
msg = '\tThe {}-th parameter is wrong'.format(-info)
else:
msg = ('\tThe leading minor of order {} is not positive definite'
.format(info))
raise RuntimeError('matrix inversion failed at potrf.\n' + msg)
b = cupy.eye(m, dtype=dtype)
# Solve: A * X = B
potrs(cusolver_handle, uplo, m, m, a.data.ptr, m, b.data.ptr, m,
dev_info.data.ptr)
info = dev_info[0]
if info > 0:
assert False, ('Unexpected output returned by potrs (actual: {})'
.format(info))
elif info < 0:
raise RuntimeError('matrix inversion failed at potrs.\n'
'\tThe {}-th parameter is wrong'.format(-info))
return b
def batched_gesv(a, b):
"""Solves multiple linear matrix equations using cublas<t>getr[fs]Batched().
Computes the solution to system of linear equation ``ax = b``.
Args:
a (cupy.ndarray): The matrix with dimension ``(..., M, M)``.
b (cupy.ndarray): The matrix with dimension ``(..., M)`` or
``(..., M, K)``.
Returns:
cupy.ndarray:
The matrix with dimension ``(..., M)`` or ``(..., M, K)``.
"""
_util._assert_cupy_array(a, b)
_util._assert_nd_squareness(a)
if not ((a.ndim == b.ndim or a.ndim == b.ndim + 1)
and a.shape[:-1] == b.shape[:a.ndim - 1]):
raise ValueError(
'a must have (..., M, M) shape and b must have (..., M) '
'or (..., M, K)')
dtype = numpy.promote_types(a.dtype.char, 'f')
if dtype == 'f':
t = 's'
elif dtype == 'd':
t = 'd'
elif dtype == 'F':
t = 'c'
elif dtype == 'D':
t = 'z'
else:
raise TypeError('invalid dtype')
getrf = getattr(cublas, t + 'getrfBatched')
getrs = getattr(cublas, t + 'getrsBatched')
bs = numpy.prod(a.shape[:-2]) if a.ndim > 2 else 1
n = a.shape[-1]
nrhs = b.shape[-1] if a.ndim == b.ndim else 1
b_shape = b.shape
a_data_ptr = a.data.ptr
b_data_ptr = b.data.ptr
a = cupy.ascontiguousarray(a.reshape(bs, n, n).transpose(0, 2, 1),
dtype=dtype)
b = cupy.ascontiguousarray(b.reshape(bs, n, nrhs).transpose(0, 2, 1),
dtype=dtype)
if a.data.ptr == a_data_ptr:
a = a.copy()
if b.data.ptr == b_data_ptr:
b = b.copy()
if n > get_batched_gesv_limit():
warnings.warn('The matrix size ({}) exceeds the set limit ({})'.format(
n, get_batched_gesv_limit()))
handle = device.get_cublas_handle()
lda = n
a_step = lda * n * a.itemsize
a_array = cupy.arange(a.data.ptr,
a.data.ptr + a_step * bs,
a_step,
dtype=cupy.uintp)
ldb = n
b_step = ldb * nrhs * b.itemsize
b_array = cupy.arange(b.data.ptr,
b.data.ptr + b_step * bs,
b_step,
dtype=cupy.uintp)
pivot = cupy.empty((bs, n), dtype=numpy.int32)
dinfo = cupy.empty((bs, ), dtype=numpy.int32)
info = numpy.empty((1, ), dtype=numpy.int32)
# LU factorization (A = L * U)
getrf(handle, n, a_array.data.ptr, lda, pivot.data.ptr, dinfo.data.ptr, bs)
_util._check_cublas_info_array_if_synchronization_allowed(getrf, dinfo)
# Solves Ax = b
getrs(handle, cublas.CUBLAS_OP_N, n, nrhs, a_array.data.ptr, lda,
pivot.data.ptr, b_array.data.ptr, ldb, info.ctypes.data, bs)
if info[0] != 0:
msg = 'Error reported by {} in cuBLAS. '.format(getrs.__name__)
if info[0] < 0:
msg += 'The {}-th parameter had an illegal value.'.format(-info[0])
raise linalg.LinAlgError(msg)
return b.transpose(0, 2, 1).reshape(b_shape)
def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
"""Solve an equation system, ``a * x = b``, given the LU factorization of ``a``
Args:
lu_and_piv (tuple): LU factorization of matrix ``a`` (``(M, M)``)
together with pivot indices.
b (cupy.ndarray): The matrix with dimension ``(M,)`` or
``(M, N)``.
trans ({0, 1, 2}): Type of system to solve:
======== =========
trans system
======== =========
0 a x = b
1 a^T x = b
2 a^H x = b
======== =========
overwrite_b (bool): Allow overwriting data in b (may enhance
performance)
check_finite (bool): Whether to check that the input matrices contain
only finite numbers. Disabling may give a performance gain, but may
result in problems (crashes, non-termination) if the inputs do
contain infinities or NaNs.
Returns:
cupy.ndarray:
The matrix with dimension ``(M,)`` or ``(M, N)``.
.. seealso:: :func:`scipy.linalg.lu_solve`
"""
(lu, ipiv) = lu_and_piv
_util._assert_cupy_array(lu)
_util._assert_rank2(lu)
_util._assert_nd_squareness(lu)
m = lu.shape[0]
if m != b.shape[0]:
raise ValueError('incompatible dimensions.')
dtype = lu.dtype
if dtype.char == 'f':
getrs = cusolver.sgetrs
elif dtype.char == 'd':
getrs = cusolver.dgetrs
elif dtype.char == 'F':
getrs = cusolver.cgetrs
elif dtype.char == 'D':
getrs = cusolver.zgetrs
else:
msg = 'Only float32, float64, complex64 and complex128 are supported.'
raise NotImplementedError(msg)
if trans == 0:
trans = cublas.CUBLAS_OP_N
elif trans == 1:
trans = cublas.CUBLAS_OP_T
elif trans == 2:
trans = cublas.CUBLAS_OP_C
else:
raise ValueError('unknown trans')
lu = lu.astype(dtype, order='F', copy=False)
ipiv = ipiv.astype(ipiv.dtype, order='F', copy=True)
# cuSolver uses 1-origin while SciPy uses 0-origin
ipiv += 1
b = b.astype(dtype, order='F', copy=(not overwrite_b))
if check_finite:
if lu.dtype.kind == 'f' and not cupy.isfinite(lu).all():
raise ValueError(
'array must not contain infs or NaNs.\n'
'Note that when a singular matrix is given, unlike '
'scipy.linalg.lu_factor, cupyx.scipy.linalg.lu_factor '
'returns an array containing NaN.')
if b.dtype.kind == 'f' and not cupy.isfinite(b).all():
raise ValueError(
'array must not contain infs or NaNs')
n = 1 if b.ndim == 1 else b.shape[1]
cusolver_handle = device.get_cusolver_handle()
dev_info = cupy.empty(1, dtype=numpy.int32)
# solve for the inverse
getrs(cusolver_handle,
trans,
m, n, lu.data.ptr, m, ipiv.data.ptr, b.data.ptr,
m, dev_info.data.ptr)
if dev_info[0] < 0:
raise ValueError('illegal value in %d-th argument of '
'internal getrs (lu_solve)' % -dev_info[0])
return b
