import unittest
import numpy
import cupy
from cupy import testing
import cupyx.scipy.linalg
if cupyx.scipy._scipy_available:
import scipy.linalg
@testing.gpu
@testing.parameterize(*testing.product({
'shape': [(1, 1), (2, 2), (3, 3), (5, 5), (1, 5), (5, 1), (2, 5), (5, 2)],
}))
@testing.fix_random()
@testing.with_requires('scipy')
class TestLUFactor(unittest.TestCase):
@testing.for_float_dtypes(no_float16=True)
def test_lu_factor(self, dtype):
if self.shape[0] != self.shape[1]:
# skip non-square tests since scipy.lu_factor requires square
return unittest.SkipTest()
array = numpy.random.randn(*self.shape)
a_cpu = numpy.asarray(array, dtype=dtype)
a_gpu = cupy.asarray(array, dtype=dtype)
result_cpu = scipy.linalg.lu_factor(a_cpu)
result_gpu = cupyx.scipy.linalg.lu_factor(a_gpu)
self.assertEqual(len(result_cpu), len(result_gpu))
self.assertEqual(result_cpu[0].dtype, result_gpu[0].dtype)
self.assertEqual(result_cpu[1].dtype, result_gpu[1].dtype)
cupy.testing.assert_allclose(result_cpu[0], result_gpu[0], atol=1e-5)
import unittest
import numpy
from cupy import testing
@testing.parameterize(*testing.product({
'shape': [(7, ), (2, 3), (4, 3, 2)],
'n_vals': [0, 1, 3, 15],
}))
@testing.gpu
class TestPlace(unittest.TestCase):
# NumPy 1.9 don't wraps values.
# https://github.com/numpy/numpy/pull/5821
@testing.with_requires('numpy>=1.10')
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal()
def test_place(self, xp, dtype):
a = testing.shaped_arange(self.shape, xp, dtype)
if self.n_vals == 0:
mask = xp.zeros(self.shape, dtype=numpy.bool_)
else:
mask = testing.shaped_random(self.shape, xp, numpy.bool_)
vals = testing.shaped_random((self.n_vals, ), xp, dtype)
xp.place(a, mask, vals)
return a
@testing.parameterize(*testing.product({
import scipy.sparse
import scipy.stats
scipy_available = True
except ImportError:
scipy_available = False
import cupy as cp
import cupy.sparse as sp
from cupy import testing
from cupy.testing import condition
import cupyx
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float64],
}))
@unittest.skipUnless(scipy_available, 'requires scipy')
class TestLschol(unittest.TestCase):
def setUp(self):
rvs = scipy.stats.randint(0, 15).rvs
self.A = scipy.sparse.random(50,
50,
density=0.2,
data_rvs=rvs,
dtype=self.dtype)
self.b = numpy.random.randint(5, size=50)
# symmetric and positive definite
self.A = self.A.T * self.A + 10 * scipy.sparse.eye(50)
self.b = self.A.T * self.b
# initial scipy results by dense cholesky method.
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose()
def test_trace(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4, 5), xp, dtype)
return a.trace(1, 3, 2)
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose()
def test_external_trace(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4, 5), xp, dtype)
return xp.trace(a, 1, 3, 2)
@testing.parameterize(*testing.product({
'shape': [(1,), (2,)],
'ord': [-numpy.Inf, -2, -1, 0, 1, 2, 3, numpy.Inf],
'axis': [0, None],
'keepdims': [True, False],
}) + testing.product({
'shape': [(1, 2), (2, 2)],
'ord': [-numpy.Inf, -1, 1, numpy.Inf, 'fro'],
'axis': [(0, 1), None],
'keepdims': [True, False],
}) + testing.product({
'shape': [(2, 2, 2)],
'ord': [-numpy.Inf, -2, -1, 0, 1, 2, 3, numpy.Inf],
'axis': [0, 1, 2],
'keepdims': [True, False],
}) + testing.product({
'shape': [(2, 2, 2)],
'ord': [-numpy.Inf, -1, 1, numpy.Inf, 'fro'],
'axis': [(0, 1), (0, 2), (1, 2)],
@testing.numpy_cupy_equal()
def test_poly1d_str(self, xp, dtype):
a = testing.shaped_arange((5, ), xp, dtype)
return str(xp.poly1d(a))
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose(rtol=1e-6)
def test_poly1d_call(self, xp, dtype):
a = testing.shaped_arange((5, ), xp, dtype)
b = xp.poly1d(a)
return b(a)
@testing.gpu
@testing.parameterize(*testing.product({
'shape': [(), (0, ), (5, )],
'exp': [0, 4, 5, numpy.int32(5), numpy.int64(5)],
}))
class TestPoly1dPow(unittest.TestCase):
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose(rtol=1e-1)
def test_poly1d_pow_scalar(self, xp, dtype):
a = testing.shaped_arange(self.shape, xp, dtype)
return xp.poly1d(a)**self.exp
@testing.gpu
@testing.parameterize(*testing.product({
'shape': [(5, ), (5, 2)],
'exp': [-10, 3.5, [1, 2, 3]],
}))
class TestPoly1dPowInvalidValue(unittest.TestCase):
import unittest
import mock
import numpy
import pytest
import cupy
from cupy import testing
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float64],
'format': ['csr', 'csc', 'coo'],
'm': [3],
'n': [None, 3, 2],
'k': [0, 1],
}))
@testing.with_requires('scipy')
class TestEye(unittest.TestCase):
@testing.numpy_cupy_allclose(sp_name='sp')
def test_eye(self, xp, sp):
x = sp.eye(
self.m, n=self.n, k=self.k, dtype=self.dtype, format=self.format)
self.assertIsInstance(x, sp.spmatrix)
self.assertEqual(x.format, self.format)
return x.toarray()
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float64],
from cupy import testing
@testing.parameterize(*testing.product({
'shape': [
((2, 3, 4), (3, 4, 2)),
((1, 1), (1, 1)),
((1, 1), (1, 2)),
((1, 2), (2, 1)),
((2, 1), (1, 1)),
((1, 2), (2, 3)),
((2, 1), (1, 3)),
((2, 3), (3, 1)),
((2, 3), (3, 4)),
((0, 3), (3, 4)),
((2, 3), (3, 0)),
((0, 3), (3, 0)),
((3, 0), (0, 4)),
((2, 3, 0), (3, 0, 2)),
((0, 0), (0, 0)),
((3, ), (3, )),
((2, ), (2, 4)),
((4, 2), (2, )),
],
'trans_a': [True, False],
'trans_b': [True, False],
}))
@testing.gpu
class TestDot(unittest.TestCase):
@testing.for_all_dtypes_combination(['dtype_a', 'dtype_b'])
@testing.numpy_cupy_allclose()
@testing.numpy_cupy_array_equal()
def test_shape_set_infer(self, xp):
arr = xp.ndarray((2, 3))
arr.shape = (3, -1)
return xp.array(arr.shape)
@testing.numpy_cupy_array_equal()
def test_shape_set_int(self, xp):
arr = xp.ndarray((2, 3))
arr.shape = 6
return xp.array(arr.shape)
@testing.parameterize(
*testing.product({
'indices_shape': [(2,), (2, 3)],
'axis': [None, 0, 1, 2, -1, -2],
})
)
@testing.gpu
class TestNdarrayTake(unittest.TestCase):
shape = (3, 4, 5)
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal()
def test_take(self, xp, dtype):
a = testing.shaped_arange(self.shape, xp, dtype)
if self.axis is None:
m = a.size
else:
m = a.shape[self.axis]
shape = numpy.array(shape)
if keepdims:
shape[axis] = 1
else:
shape[axis] = -1
shape = filter(lambda x: x != -1, shape)
return tuple(shape)
@testing.parameterize(
*testing.product(
{
"f": ["all", "any"],
"x": [numpy.arange(24).reshape(2, 3, 4) - 10, numpy.zeros((2, 3, 4)), numpy.ones((2, 3, 4))],
"axis": [None, (0, 1, 2), 0, 1, 2, (0, 1)],
"keepdims": [False, True],
}
)
)
@testing.gpu
class TestAllAny(unittest.TestCase):
_multiprocess_can_split_ = True
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal()
def test_without_out(self, xp, dtype):
x = xp.asarray(self.x).astype(dtype)
return getattr(xp, self.f)(x, self.axis, None, self.keepdims)
@testing.numpy_cupy_allclose(atol=1e-3)
def check_L(self, array, xp, dtype):
a = xp.asarray(array, dtype=dtype)
return xp.linalg.cholesky(a)
def test_decomposition(self):
# A normal positive definite matrix
A = numpy.random.randint(0, 100, size=(5, 5))
A = numpy.dot(A, A.transpose())
self.check_L(A)
# np.linalg.cholesky only uses a lower triangle of an array
self.check_L(numpy.array([[1, 2], [1, 9]]))
@testing.parameterize(*testing.product({
'mode': ['r', 'raw', 'complete', 'reduced'],
}))
@unittest.skipUnless(
cuda.cusolver_enabled, 'Only cusolver in CUDA 8.0 is supported')
@testing.gpu
class TestQRDecomposition(unittest.TestCase):
_multiprocess_can_split_ = True
@testing.for_float_dtypes(no_float16=True)
def check_mode(self, array, mode, dtype):
a_cpu = numpy.asarray(array, dtype=dtype)
a_gpu = cupy.asarray(array, dtype=dtype)
result_cpu = numpy.linalg.qr(a_cpu, mode=mode)
result_gpu = cupy.linalg.qr(a_gpu, mode=mode)
if isinstance(result_cpu, tuple):
import cupy.cuda.cudnn as libcudnn
cudnn_enabled = True
modes = [
libcudnn.CUDNN_ACTIVATION_SIGMOID,
libcudnn.CUDNN_ACTIVATION_RELU,
libcudnn.CUDNN_ACTIVATION_TANH,
]
import cupy.cudnn
except ImportError:
cudnn_enabled = False
modes = []
from cupy import testing
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float64],
'mode': modes,
}))
@unittest.skipUnless(
cudnn_enabled and libcudnn.getVersion() >= 3000,
'cuDNN >= 3.0 is supported')
class TestCudnnActivation(unittest.TestCase):
def setUp(self):
self.x = testing.shaped_arange((3, 4), cupy, self.dtype)
self.y = testing.shaped_arange((3, 4), cupy, self.dtype)
self.g = testing.shaped_arange((3, 4), cupy, self.dtype)
def test_activation_forward_version(self):
if libcudnn.getVersion() >= 4000:
patch = 'cupy.cuda.cudnn.activationForward_v4'
else:
def test_product(self):
self.assertListEqual(testing.product(self.actual), self.expect)
import copy
import unittest
import numpy
import six
import cupy
from cupy import testing
@testing.parameterize(
*testing.product({
'assertion': ['assert_allclose', 'assert_array_almost_equal',
'assert_array_almost_equal_nulp',
'assert_array_max_ulp', 'assert_array_equal'],
'array_module_x': [numpy, cupy],
'array_module_y': [numpy, cupy]
})
)
@testing.gpu
class TestEqualityAssertion(unittest.TestCase):
def setUp(self):
self.assertion = getattr(testing, self.assertion)
val = numpy.random.uniform(-1, 1, (2, 3))
self.x = self.array_module_x.array(val, val.dtype, copy=True)
self.y = self.array_module_y.array(val, val.dtype, copy=True)
def test_equality(self):
self.assertion(self.x, self.y)
@testing.parameterize(
*testing.product(
{
"shape_pair": [
((3, 2), (2, 4)),
((2,), (2, 4)),
((3, 2), (2,)),
((2,), (2,)),
((5, 3, 2), (5, 2, 4)),
((5, 3, 2), (2, 4)),
((3, 2), (5, 2, 4)),
((5, 3, 2), (1, 2, 4)),
((1, 3, 2), (5, 2, 4)),
((5, 3, 2), (2,)),
((2,), (5, 2, 4)),
((6, 5, 3, 2), (6, 5, 2, 4)),
((6, 5, 3, 2), (6, 1, 2, 4)),
((6, 5, 3, 2), (1, 5, 2, 4)),
((6, 5, 3, 2), (1, 1, 2, 4)),
((6, 1, 3, 2), (6, 5, 2, 4)),
((1, 5, 3, 2), (6, 5, 2, 4)),
((1, 1, 3, 2), (6, 5, 2, 4)),
((3, 2), (6, 5, 2, 4)),
((6, 5, 3, 2), (2, 4)),
((2,), (6, 5, 2, 4)),
((6, 5, 3, 2), (2,)),
]
}
)
)
@testing.gpu
for xp in (numpy, cupy):
a = xp.asarray(array)
with cupyx.errstate(linalg='raise'):
with pytest.raises(numpy.linalg.LinAlgError):
xp.linalg.cholesky(a)
@testing.for_dtypes([
numpy.int32, numpy.int64, numpy.uint32, numpy.uint64,
numpy.float32, numpy.float64])
def test_decomposition(self, dtype):
A = numpy.array([[1, -2], [-2, 1]]).astype(dtype)
self.check_L(A)
@testing.parameterize(*testing.product({
'mode': ['r', 'raw', 'complete', 'reduced'],
}))
@testing.gpu
class TestQRDecomposition(unittest.TestCase):
@testing.for_dtypes('fdFD')
def check_mode(self, array, mode, dtype):
a_cpu = numpy.asarray(array, dtype=dtype)
a_gpu = cupy.asarray(array, dtype=dtype)
result_cpu = numpy.linalg.qr(a_cpu, mode=mode)
result_gpu = cupy.linalg.qr(a_gpu, mode=mode)
if isinstance(result_cpu, tuple):
for b_cpu, b_gpu in zip(result_cpu, result_gpu):
assert b_cpu.dtype == b_gpu.dtype
cupy.testing.assert_allclose(b_cpu, b_gpu, atol=1e-4)
else:
@testing.parameterize(
*testing.product({
'shape_pair': [
((3, 2), (2, 4)),
((2,), (2, 4)),
((3, 2), (2,)),
((2,), (2,)),
((5, 3, 2), (5, 2, 4)),
((5, 3, 2), (2, 4)),
((3, 2), (5, 2, 4)),
((5, 3, 2), (1, 2, 4)),
((1, 3, 2), (5, 2, 4)),
((5, 3, 2), (2,)),
((2,), (5, 2, 4)),
((6, 5, 3, 2), (6, 5, 2, 4)),
((6, 5, 3, 2), (6, 1, 2, 4)),
((6, 5, 3, 2), (1, 5, 2, 4)),
((6, 5, 3, 2), (1, 1, 2, 4)),
((6, 1, 3, 2), (6, 5, 2, 4)),
((1, 5, 3, 2), (6, 5, 2, 4)),
((1, 1, 3, 2), (6, 5, 2, 4)),
((3, 2), (6, 5, 2, 4)),
((6, 5, 3, 2), (2, 4)),
((2,), (6, 5, 2, 4)),
((6, 5, 3, 2), (2,)),
],
}))
@testing.gpu
class TestMatmul(unittest.TestCase):
import cupy
from cupy import testing
def perm(iterable):
return list(itertools.permutations(iterable))
@testing.parameterize(*testing.product({
'shape': [(4, 4, 4)],
'indexes': (perm(([1, 0], slice(None))) + perm(([1, 0], Ellipsis)) + perm(
([1, 2], None, slice(None))) + perm(([1, 0], 1, slice(None))) + perm(
([1, 2], slice(0, 2), slice(None))) + perm((1, [1, 2], 1)) + perm(
([[1, -1], [0, 3]], slice(None), slice(None))) + perm(
([1, 0], [3, 2], slice(None))) + perm(
(slice(0, 3, 2), [1, 2], [1, 0])) + perm(
([1, 0], [2, 1], [3, 1])) +
perm(([1, 0], 1, [3, 1])) + perm(
([1, 2], [[1, 0], [0, 1], [-1, 1]], slice(None))) + perm(
(None, [1, 2], [1, 0])) + perm(
(numpy.array(0), numpy.array(-1))) + perm(
(numpy.array(0), None)) + perm(
(1, numpy.array(2), slice(None))))
}))
@testing.gpu
class TestArrayAdvancedIndexingGetitemPerm(unittest.TestCase):
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal()
def test_adv_getitem(self, xp, dtype):
a = testing.shaped_arange(self.shape, xp, dtype)
return a[self.indexes]
import unittest
import cupy
from cupy.random import distributions
from cupy import testing
@testing.parameterize(*testing.product({
'shape': [(4, 3, 2), (3, 2)],
'loc_shape': [(), (3, 2)],
'scale_shape': [(), (3, 2)],
})
)
@testing.gpu
class TestDistributions(unittest.TestCase):
_multiprocess_can_split_ = True
def check_distribution(self, dist_func, loc_dtype, scale_dtype, dtype):
loc = cupy.ones(self.loc_shape, dtype=loc_dtype)
scale = cupy.ones(self.scale_shape, dtype=scale_dtype)
out = dist_func(loc, scale, self.shape, dtype)
self.assertEqual(self.shape, out.shape)
self.assertEqual(out.dtype, dtype)
@cupy.testing.for_float_dtypes('dtype', no_float16=True)
@cupy.testing.for_float_dtypes('loc_dtype')
@cupy.testing.for_float_dtypes('scale_dtype')
def test_normal(self, loc_dtype, scale_dtype, dtype):
self.check_distribution(distributions.normal,
loc_dtype, scale_dtype, dtype)
def _make_shape(xp, sp, dtype):
return sp.coo_matrix((3, 4))
def _make_sum_dup(xp, sp, dtype):
# 1 0 0
# 1 1 0
# 1 1 1
data = xp.array([1, 1, 1, 1, 1, 1], dtype)
row = xp.array([0, 1, 1, 2, 2, 2], 'i')
col = xp.array([0, 0, 1, 0, 1, 2], 'i')
return sp.coo_matrix((data, (row, col)), shape=(3, 3))
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float64, numpy.complex64, numpy.complex128],
}))
class TestCooMatrix:
@pytest.fixture(autouse=True)
def setUp(self):
self.m = _make(cupy, sparse, self.dtype)
def test_dtype(self):
assert self.m.dtype == self.dtype
def test_data(self):
assert self.m.data.dtype == self.dtype
testing.assert_array_equal(self.m.data,
cupy.array([0, 1, 2, 3], self.dtype))
def test_row(self):
def perm(iterable):
return list(itertools.permutations(iterable))
@testing.parameterize(
*testing.product({
'shape': [(4, 4, 4)],
'indexes': (
perm(([1, 0], slice(None))) +
perm(([1, 0], Ellipsis)) +
perm(([1, 2], None, slice(None))) +
perm(([1, 0], 1, slice(None))) +
perm(([1, 2], slice(0, 2), slice(None))) +
perm((1, [1, 2], 1)) +
perm(([[1, -1], [0, 3]], slice(None), slice(None))) +
perm(([1, 0], [3, 2], slice(None))) +
perm((slice(0, 3, 2), [1, 2], [1, 0])) +
perm(([1, 0], [2, 1], [3, 1])) +
perm(([1, 0], 1, [3, 1])) +
perm(([1, 2], [[1, 0], [0, 1], [-1, 1]], slice(None))) +
perm((None, [1, 2], [1, 0])) +
perm((numpy.array(0), numpy.array(-1))) +
perm((numpy.array(0), None)) +
perm((1, numpy.array(2), slice(None)))
)
})
)
@testing.gpu
class TestArrayAdvancedIndexingGetitemPerm(unittest.TestCase):
@testing.for_all_dtypes()
# from #3232
a = testing.shaped_random((4, 8), xp, dtype=xp.float64)
a = a.T[::-1]
return xp.lexsort(a)
@testing.numpy_cupy_array_equal()
def test_F_order(self, xp):
a = testing.shaped_random((4, 8), xp, dtype=xp.float64)
a = xp.asfortranarray(a)
assert a.flags.f_contiguous
assert not a.flags.c_contiguous
return xp.lexsort(a)
@testing.parameterize(*testing.product({
'external': [False, True],
}))
@testing.gpu
class TestArgsort(unittest.TestCase):
def argsort(self, a, axis=-1):
if self.external:
xp = cupy.get_array_module(a)
return xp.argsort(a, axis=axis)
else:
return a.argsort(axis=axis)
# Test base cases
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal()
def test_argsort_zero_dim(self, xp, dtype):
def test_shape(self):
a = core.ndarray(self.arg)
self.assertTupleEqual(a.shape, self.shape)
class TestNdarrayInitRaise(unittest.TestCase):
def test_unsupported_type(self):
arr = numpy.ndarray((2, 3), dtype=object)
with self.assertRaises(ValueError):
core.array(arr)
@testing.parameterize(
*testing.product({
'indices_shape': [(2,), (2, 3)],
'axis': [None, 0, 1],
})
)
class TestNdarrayTake(unittest.TestCase):
shape = (3, 4, 5)
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal(accept_error=False)
def test_take(self, xp, dtype):
a = testing.shaped_arange(self.shape, xp, dtype)
if self.axis is None:
m = a.size
else:
m = a.shape[self.axis]
i = testing.shaped_arange(self.indices_shape, xp, numpy.int32) % m
@testing.numpy_cupy_allclose(atol=1e-3)
def check_L(self, array, xp, dtype):
a = xp.asarray(array, dtype=dtype)
return xp.linalg.cholesky(a)
def test_decomposition(self):
# A normal positive definite matrix
A = numpy.random.randint(0, 100, size=(5, 5))
A = numpy.dot(A, A.transpose())
self.check_L(A)
# np.linalg.cholesky only uses a lower triangle of an array
self.check_L(numpy.array([[1, 2], [1, 9]]))
@testing.parameterize(*testing.product({
'mode': ['r', 'raw', 'complete', 'reduced'],
}))
@unittest.skipUnless(
cuda.cusolver_enabled, 'Only cusolver in CUDA 8.0 is supported')
@testing.gpu
class TestQRDecomposition(unittest.TestCase):
_multiprocess_can_split_ = True
@testing.for_float_dtypes(no_float16=True)
def check_mode(self, array, mode, dtype):
a_cpu = numpy.asarray(array, dtype=dtype)
a_gpu = cupy.asarray(array, dtype=dtype)
result_cpu = numpy.linalg.qr(a_cpu, mode=mode)
result_gpu = cupy.linalg.qr(a_gpu, mode=mode)
if isinstance(result_cpu, tuple):
class TestMatDescriptor:
def test_create(self):
md = cusparse.MatDescriptor.create()
assert isinstance(md.descriptor, int)
def test_pickle(self):
md = cusparse.MatDescriptor.create()
md2 = pickle.loads(pickle.dumps(md))
assert isinstance(md2.descriptor, int)
assert md.descriptor != md2.descriptor
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float64],
'transa': [True, False],
}))
@testing.with_requires('scipy')
class TestCsrmm:
alpha = 0.5
beta = 0.25
@pytest.fixture(autouse=True)
def setUp(self):
self.op_a = scipy.sparse.random(2, 3, density=0.5, dtype=self.dtype)
if self.transa:
self.a = self.op_a.T
else:
self.a = self.op_a
self.b = numpy.random.uniform(-1, 1, (3, 4)).astype(self.dtype)
@testing.numpy_cupy_array_equal()
def test_fromfile(self, xp):
with tempfile.TemporaryFile() as fh:
fh.write(b"\x00\x01\x02\x03\x04")
fh.flush()
fh.seek(0)
return xp.fromfile(fh, dtype="u1")
max_cuda_array_interface_version = 3
@testing.gpu
@testing.parameterize(*testing.product({
'ver':
tuple(range(max_cuda_array_interface_version + 1)),
'strides': (False, None, True),
}))
@pytest.mark.skipif(cupy.cuda.runtime.is_hip,
reason='HIP does not support this')
class TestCudaArrayInterface(unittest.TestCase):
@testing.for_all_dtypes()
def test_base(self, dtype):
a = testing.shaped_arange((2, 3, 4), cupy, dtype)
b = cupy.asarray(
DummyObjectWithCudaArrayInterface(a, self.ver, self.strides))
testing.assert_array_equal(a, b)
@testing.for_all_dtypes()
def test_not_copied(self, dtype):
a = testing.shaped_arange((2, 3, 4), cupy, dtype)
def test_product(self):
self.assertListEqual(testing.product(self.actual), self.expect)
libcudnn.CUDNN_TENSOR_NHWC,
]
cudnn_version = libcudnn.getVersion()
if cudnn_version >= 6000:
coef_modes.append(libcudnn.CUDNN_ACTIVATION_ELU)
from cupy import cudnn
else:
cudnn_version = -1
modes = []
coef_modes = []
layouts = []
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float64],
'mode': modes,
}))
@unittest.skipUnless(cudnn_enabled, 'cuDNN is not available')
class TestCudnnActivation(unittest.TestCase):
def setUp(self):
self.x = testing.shaped_arange((3, 4), cupy, self.dtype)
self.y = testing.shaped_arange((3, 4), cupy, self.dtype)
self.g = testing.shaped_arange((3, 4), cupy, self.dtype)
def test_activation_forward(self):
cudnn.activation_forward(self.x, self.mode)
def test_activation_backward(self):
cudnn.activation_backward(self.x, self.y, self.g, self.mode)
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose()
def test_trace(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4, 5), xp, dtype)
return a.trace(1, 3, 2)
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose()
def test_external_trace(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4, 5), xp, dtype)
return xp.trace(a, 1, 3, 2)
@testing.parameterize(*testing.product({
'shape': [(1, ), (2, )],
'ord': [-numpy.Inf, -2, -1, 0, 1, 2, 3, numpy.Inf],
'axis': [0, None],
'keepdims': [True, False],
}) + testing.product({
'shape': [(1, 2), (2, 2)],
'ord': [-numpy.Inf, -1, 1, numpy.Inf, 'fro'],
'axis': [(0, 1), None],
'keepdims': [True, False],
}) + testing.product({
'shape': [(2, 2, 2)],
'ord': [-numpy.Inf, -2, -1, 0, 1, 2, 3, numpy.Inf],
'axis': [0, 1, 2],
'keepdims': [True, False],
}) + testing.product({
'shape': [(2, 2, 2)],
'ord': [-numpy.Inf, -1, 1, numpy.Inf, 'fro'],
'axis': [(0, 1), (0, 2), (1, 2)],
import numpy
import pytest
import cupy
from cupy import cublas
from cupy import testing
from cupy.testing import _attr
@testing.parameterize(*testing.product({
'dtype': ['float32', 'float64', 'complex64', 'complex128'],
'n': [10, 33, 100],
'bs': [None, 1, 10],
'nrhs': [None, 1, 10],
}))
@_attr.gpu
class TestBatchedGesv:
_tol = {'f': 5e-5, 'd': 1e-12}
def _make_random_matrices(self, shape, xp):
a = testing.shaped_random(shape, xp, dtype=self.r_dtype, scale=1)
if self.dtype.char in 'FD':
a = a + 1j * testing.shaped_random(shape, xp, dtype=self.r_dtype,
scale=1)
return a
def _make_well_conditioned_matrices(self, shape):
a = self._make_random_matrices(shape, numpy)
u, s, vh = numpy.linalg.svd(a)
s = testing.shaped_random(s.shape, numpy, dtype=self.r_dtype,
scale=1) + 1
return xp.unique(a, return_index=True)[1]
@testing.for_all_dtypes(no_float16=True, no_bool=True, no_complex=True)
@testing.numpy_cupy_array_equal()
def test_unique_inverse(self, xp, dtype):
a = testing.shaped_random((100, 100), xp, dtype)
return xp.unique(a, return_inverse=True)[1]
@testing.for_all_dtypes(no_float16=True, no_bool=True, no_complex=True)
@testing.numpy_cupy_array_equal()
def test_unique_counts(self, xp, dtype):
a = testing.shaped_random((100, 100), xp, dtype)
return xp.unique(a, return_counts=True)[1]
@testing.parameterize(*testing.product({'trim': ['fb', 'f', 'b']}))
@testing.gpu
class TestTrim_zeros(unittest.TestCase):
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal()
def test_trim_non_zeros(self, xp, dtype):
a = xp.array([-1, 2, -3, 7], dtype=dtype)
return xp.trim_zeros(a, trim=self.trim)
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal()
def test_trim_trimmed(self, xp, dtype):
a = xp.array([1, 0, 2, 3, 0, 5], dtype=dtype)
return xp.trim_zeros(a, trim=self.trim)
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose(atol=1e-3)
def check_L(self, array, xp, dtype):
a = xp.asarray(array, dtype=dtype)
return xp.linalg.cholesky(a)
def test_decomposition(self):
# A normal positive definite matrix
A = numpy.random.randint(0, 100, size=(5, 5))
A = numpy.dot(A, A.transpose())
self.check_L(A)
# np.linalg.cholesky only uses a lower triangle of an array
self.check_L(numpy.array([[1, 2], [1, 9]]))
@testing.parameterize(*testing.product({
'mode': ['r', 'raw', 'complete', 'reduced'],
}))
@unittest.skipUnless(cuda.cusolver_enabled,
'Only cusolver in CUDA 8.0 is supported')
@testing.gpu
class TestQRDecomposition(unittest.TestCase):
_multiprocess_can_split_ = True
@testing.for_float_dtypes(no_float16=True)
def check_mode(self, array, mode, dtype):
a_cpu = numpy.asarray(array, dtype=dtype)
a_gpu = cupy.asarray(array, dtype=dtype)
result_cpu = numpy.linalg.qr(a_cpu, mode=mode)
result_gpu = cupy.linalg.qr(a_gpu, mode=mode)
if isinstance(result_cpu, tuple):
'shape': [(4, 5), (3, 4, 5), (1, 3, 4, 5)],
'ksize': [3, 4],
'dtype': [numpy.uint8, numpy.float64],
}
# Floating point dtypes only
COMMON_FLOAT_PARAMS = dict(COMMON_PARAMS)
COMMON_FLOAT_PARAMS['dtype'] = [numpy.float32, numpy.float64]
# The bulk of the tests are done with this class
@testing.parameterize(*(
testing.product_dict(
# Filter-function specific params
testing.product({
'filter': ['convolve', 'correlate'],
}) + testing.product({
'filter': ['convolve1d', 'correlate1d', 'minimum_filter1d'],
'axis': [0, 1, -1],
}) + testing.product({
'filter': ['minimum_filter', 'median_filter'],
'footprint': [False, True],
}),
# Mode-specific params
testing.product({
**COMMON_PARAMS,
'mode': ['reflect'],
# With reflect test some of the other parameters as well
'origin': [0, 1, (-1, 1, -1, 1)],
'output': [None, numpy.uint8, numpy.float64],
desc_c, ('x', ),
reduce_op=ct.OP_MAX)
assert c is d
testing.assert_allclose(
self.alpha * cupy.cos(self.a_transposed).max(axis=(1, 2)) +
self.beta * cupy.tanh(c_orig),
d,
rtol=1e-6,
atol=1e-6)
@testing.parameterize(*testing.product({
'dtype_combo': ['eee', 'fff', 'ddd', 'FFF', 'DDD', 'dDD', 'DdD'],
'compute_type_hint': [None, 'down-convert', 'TF32'],
'shape': [(40, 30, 20)],
'alpha': [1.0],
'beta': [0.0, 1.0],
}))
@unittest.skipUnless(ct.available, 'cuTensor is unavailable')
class TestCuTensorContraction(unittest.TestCase):
_tol = {'e': 1e-3, 'f': 1e-6, 'd': 1e-12}
def make_random_array(self, shape, dtype):
return testing.shaped_random(shape, cupy, dtype=dtype, scale=1)
def make_matrix(self, shape, dtype):
r_dtype = dtype
if dtype == numpy.complex64:
r_dtype = numpy.float32
elif dtype == numpy.complex128:
testing.product([
# Filter-function specific params
testing.product({
'filter': ['convolve', 'correlate'],
}) + testing.product({
'filter': ['convolve1d', 'correlate1d', 'minimum_filter1d'],
'axis': [0, 1, -1],
}) + testing.product({
'filter': ['minimum_filter', 'median_filter'],
'footprint': [False, True],
}),
# Mode-specific params
testing.product({
**COMMON_PARAMS,
'mode': ['reflect'],
# With reflect test some of the other parameters as well
'origin': [0, 1, (-1, 1, -1, 1)],
'output': [None, numpy.uint8, numpy.float64],
}) + testing.product({
**COMMON_PARAMS,
'mode': ['constant'],
'cval': [-1.0, 0.0, 1.0],
}) + testing.product({
**COMMON_PARAMS,
'mode': ['nearest', 'wrap'],
}) + testing.product({
**COMMON_PARAMS,
'shape': [(4, 5), (3, 4, 5)], # no (1,3,4,5) due to scipy bug
'mode': ['mirror'],
})
])))
def __cuda_array_interface__(self):
desc = {
'shape': self.a.shape,
'typestr': self.a.dtype.str,
'descr': self.a.dtype.descr,
'data': (self.a.data.mem.ptr, False),
'version': 0,
}
if self.has_strides:
desc['strides'] = self.a.strides
return desc
@testing.parameterize(*testing.product({
'ndmin': [0, 1, 2, 3],
'copy': [True, False],
'xp': [numpy, cupy]
}))
class TestArrayPreservationOfShape(unittest.TestCase):
@testing.for_all_dtypes()
def test_cupy_array(self, dtype):
shape = 2, 3
a = testing.shaped_arange(shape, self.xp, dtype)
cupy.array(a, copy=self.copy, ndmin=self.ndmin)
# Check if cupy.ndarray does not alter
# the shape of the original array.
assert a.shape == shape
@testing.parameterize(*testing.product({
data = data - 1j
offsets = xp.array([0, -1], 'i')
# 0, 0, 0, 0
# 3 - 1j, 1 - 1j, 0, 0
# 0, 4 - 1j, 2 - 1j, 0
return sp.dia_matrix((data, offsets), shape=(3, 4))
def _make_empty(xp, sp, dtype):
data = xp.array([[]], 'f')
offsets = xp.array([0], 'i')
return sp.dia_matrix((data, offsets), shape=(3, 4))
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float64, numpy.complex64, numpy.complex128],
}))
class TestDiaMatrix(unittest.TestCase):
def setUp(self):
self.m = _make(cupy, sparse, self.dtype)
def test_dtype(self):
self.assertEqual(self.m.dtype, self.dtype)
def test_data(self):
self.assertEqual(self.m.data.dtype, self.dtype)
testing.assert_array_equal(
self.m.data, cupy.array([[0, 1, 2], [3, 4, 5]], self.dtype))
def test_offsets(self):
self.assertEqual(self.m.offsets.dtype, numpy.int32)
try:
import scipy.ndimage
except ImportError:
pass
try:
import cv2
except ImportError:
pass
@testing.parameterize(*testing.product({
'output': [None, numpy.float64, 'f', float, 'empty'],
'order': [0, 1],
'mode': ['constant', 'nearest', 'mirror'],
'cval': [1.0],
'prefilter': [True],
}))
@testing.gpu
@testing.with_requires('scipy')
class TestMapCoordinates(unittest.TestCase):
_multiprocess_can_split = True
def _map_coordinates(self, xp, scp, a, coordinates):
# scipy.ndimage has bug with Python2
if sys.version_info[0] == 2 and self.output == 'f':
return xp.empty(0)
map_coordinates = scp.ndimage.map_coordinates
import cupy
from cupy.cuda import runtime
from cupy import testing
import cupyx.scipy.signal
try:
import scipy.signal # NOQA
except ImportError:
pass
@testing.parameterize(*testing.product({
'size1': [(10,), (5, 10), (10, 3), (3, 4, 10)],
'size2': [3, 4, 5, 10],
'mode': ['full', 'same', 'valid'],
}))
@testing.gpu
@testing.with_requires('scipy')
class TestConvolveCorrelate(unittest.TestCase):
def _filter(self, func, dtype, xp, scp):
in1 = testing.shaped_random(self.size1, xp, dtype)
in2 = testing.shaped_random((self.size2,)*in1.ndim, xp, dtype)
return getattr(scp.signal, func)(in1, in2, self.mode, method='direct')
tols = {np.float32: 1e-5, np.complex64: 1e-5,
np.float16: 1e-3, 'default': 1e-10}
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose(atol=tols, rtol=tols, scipy_name='scp',
import unittest
import pytest
import cupy
from cupy import testing
import cupyx.scipy.fftpack # NOQA
from cupy.fft.fft import _default_fft_func, _fftn
if cupyx.scipy._scipy_available:
import scipy.fftpack # NOQA
@testing.parameterize(*testing.product({
'n': [None, 0, 5, 10, 15],
'shape': [(9, ), (10, ), (10, 9), (10, 10)],
'axis': [-1, 0],
}))
@testing.gpu
@testing.with_requires('scipy>=0.19.0')
class TestFft(unittest.TestCase):
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose(rtol=1e-4,
atol=1e-7,
accept_error=ValueError,
contiguous_check=False,
scipy_name='scp')
def test_fft(self, xp, scp, dtype):
x = testing.shaped_random(self.shape, xp, dtype)
x_orig = x.copy()
out = scp.fftpack.fft(x, n=self.n, axis=self.axis)
testing.assert_array_equal(x, x_orig)
@testing.for_all_dtypes(no_float16=True, no_bool=True, no_complex=True)
@testing.numpy_cupy_allclose()
def test_lexsort_dtype(self, xp, dtype):
a = testing.shaped_random((2, 10), xp, dtype)
return xp.lexsort(a)
@testing.for_dtypes([numpy.float16, numpy.bool_])
def test_lexsort_unsupported_dtype(self, dtype):
a = testing.shaped_random((2, 10), cupy, dtype)
with self.assertRaises(TypeError):
return cupy.lexsort(a)
@testing.parameterize(*testing.product({
'external': [False, True],
}))
@testing.gpu
class TestArgsort(unittest.TestCase):
_multiprocess_can_split_ = True
def argsort(self, a, axis=-1):
if self.external:
xp = cupy.get_array_module(a)
return xp.argsort(a, axis=axis)
else:
return a.argsort(axis=axis)
# Test base cases
def test_fix(self):
self.check_unary('fix')
self.check_unary_complex_unsupported('fix')
def test_around(self):
self.check_unary('around')
self.check_unary_complex('around')
def test_round_(self):
self.check_unary('round_')
self.check_unary_complex('around')
@testing.parameterize(*testing.product({
'decimals': [-2, -1, 0, 1, 2],
}))
class TestRound(unittest.TestCase):
shape = (20, )
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose(atol=1e-5)
def test_round(self, xp, dtype):
if dtype == numpy.bool_:
# avoid cast problem
a = testing.shaped_random(self.shape, xp, scale=10, dtype=dtype)
return xp.around(a, 0)
if dtype == numpy.float16:
# avoid accuracy problem
a = testing.shaped_random(self.shape, xp, scale=10, dtype=dtype)
import copy
import unittest
import numpy
import six
import cupy
from cupy import testing
@testing.parameterize(*testing.product({
'assertion': [
'assert_allclose', 'assert_array_almost_equal',
'assert_array_almost_equal_nulp', 'assert_array_max_ulp',
'assert_array_equal'
],
'array_module_x': [numpy, cupy],
'array_module_y': [numpy, cupy]
}))
@testing.gpu
class TestEqualityAssertion(unittest.TestCase):
def setUp(self):
self.assertion = getattr(testing, self.assertion)
val = numpy.random.uniform(-1, 1, (2, 3))
self.x = self.array_module_x.array(val, val.dtype, copy=True)
self.y = self.array_module_y.array(val, val.dtype, copy=True)
def test_equality(self):
self.assertion(self.x, self.y)
def test_inequality(self):
from cupy import testing
@testing.parameterize(*testing.product({
'shape': [
((2, 3, 4), (3, 4, 2)),
((1, 1), (1, 1)),
((1, 1), (1, 2)),
((1, 2), (2, 1)),
((2, 1), (1, 1)),
((1, 2), (2, 3)),
((2, 1), (1, 3)),
((2, 3), (3, 1)),
((2, 3), (3, 4)),
((0, 3), (3, 4)),
((2, 3), (3, 0)),
((0, 3), (3, 0)),
((3, 0), (0, 4)),
((2, 3, 0), (3, 0, 2)),
((0, 0), (0, 0)),
((3,), (3,)),
((2,), (2, 4)),
((4, 2), (2,)),
],
'trans_a': [True, False],
'trans_b': [True, False],
}))
@testing.gpu
class TestDot(unittest.TestCase):
_multiprocess_can_split_ = True
def check_array_op(self, op, xp, dtype):
a = testing.shaped_arange((2, 3), xp, dtype)
return op(a)
def test_invert_array(self):
self.check_array_op(operator.invert)
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose(accept_error=TypeError)
def check_zerodim_op(self, op, xp, dtype):
a = xp.array(-2, dtype)
return op(a)
def test_invert_zerodim(self):
self.check_zerodim_op(operator.invert)
@testing.parameterize(*testing.product({
'xp': [numpy, cupy],
'shape': [(3, 2), (), (3, 0, 2)]
}))
class TestBoolNeg(unittest.TestCase):
def test_bool_neg(self):
xp = self.xp
if xp is numpy and not testing.numpy_satisfies('>=1.13.0'):
raise unittest.SkipTest('NumPy<1.13.0')
shape = self.shape
x = testing.shaped_random(shape, xp, dtype=numpy.bool_)
with pytest.raises(TypeError):
-x
import unittest
from cupy import testing
@testing.parameterize(*testing.product({
'shape': [(3, 3), (2, 2, 2), (3, 5), (5, 3)],
'val': [1, 0],
'wrap': [True, False],
}))
@testing.gpu
class TestInsert(unittest.TestCase):
_multiprocess_can_split_ = True
@testing.for_all_dtypes()
@testing.numpy_cupy_array_equal()
def test_fill_diagonal(self, xp, dtype):
a = testing.shaped_arange(self.shape, xp, dtype)
xp.fill_diagonal(a, val=self.val, wrap=self.wrap)
return a
@testing.for_all_dtypes()
@testing.numpy_cupy_raises()
def test_1darray(self, xp, dtype):
a = testing.shaped_arange(5, xp, dtype)
xp.fill_diagonal(a, val=self.val, wrap=self.wrap)
@testing.numpy_cupy_allclose()
def test_prod_axis(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return a.prod(axis=1)
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose()
def test_external_prod_axis(self, xp, dtype):
a = testing.shaped_arange((2, 3, 4), xp, dtype)
return xp.prod(a, axis=1)
axes = [0, 1, 2]
@testing.parameterize(*testing.product({'axis': axes}))
@testing.gpu
class TestCumsum(unittest.TestCase):
_multiprocess_can_split_ = True
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose()
def test_cumsum(self, xp, dtype):
a = testing.shaped_arange((5,), xp, dtype)
return xp.cumsum(a)
@testing.for_all_dtypes()
@testing.numpy_cupy_allclose()
def test_cumsum_2dim(self, xp, dtype):
a = testing.shaped_arange((4, 5), xp, dtype)