Update linalg tests to run on CUDA

Author: vlad-perevezentsev

dpnp/tests/test_linalg.py

@@ -23,6 +23,7 @@
     get_float_complex_dtypes,
     has_support_aspect64,
     is_cpu_device,
+    is_cuda_device,
 )
 from .third_party.cupy import testing
 
@@ -367,6 +368,7 @@ def test_cond_complex(self, dtype, shape, p):
         expected = numpy.linalg.cond(a, p=p)
         assert_dtype_allclose(result, expected)
 
+    @pytest.mark.skipif(is_cuda_device(), reason="SAT-7589")
     @pytest.mark.parametrize(
         "p",
         [-inp.inf, -1, 1, inp.inf, "fro"],
@@ -387,6 +389,9 @@ def test_cond_nan_input(self, p):
         ids=["None", "-dpnp.inf", "-2", "-1", "1", "2", "dpnp.inf", "fro"],
     )
     def test_cond_nan(self, p):
+        if is_cuda_device():
+            if p in [-inp.inf, -1, 1, inp.inf, "fro"]:
+                pytest.skip("SAT-7589")
         a = numpy.array(numpy.random.uniform(-5, 5, 16)).reshape(2, 2, 2, 2)
         a[0, 0] = 0
         a[1, 1] = 0
@@ -1893,6 +1898,9 @@ class TestLstsq:
         ],
     )
     def test_lstsq(self, a_shape, b_shape, dtype):
+        if is_cuda_device():
+            if a_shape == (2, 4):
+                pytest.skip("SAT-7589")
         a_np = numpy.random.rand(*a_shape).astype(dtype)
         b_np = numpy.random.rand(*b_shape).astype(dtype)
 
@@ -2272,6 +2280,9 @@ def test_norm_1D_complex(self, dtype, ord, axis, keepdims):
     )
     @pytest.mark.parametrize("keepdims", [True, False])
     def test_norm_2D(self, dtype, ord, axis, keepdims):
+        if is_cuda_device():
+            if ord in [-2, 2, "nuc"] and axis == None:
+                pytest.skip("SAT-7589")
         a = numpy.array(numpy.random.uniform(-5, 5, 15), dtype=dtype).reshape(
             3, 5
         )
@@ -2299,6 +2310,9 @@ def test_norm_2D(self, dtype, ord, axis, keepdims):
     )
     @pytest.mark.parametrize("keepdims", [True, False])
     def test_norm_2D_complex(self, dtype, ord, axis, keepdims):
+        if is_cuda_device():
+            if ord in [-2, 2, "nuc"] and axis == None:
+                pytest.skip("SAT-7589")
         x1 = numpy.random.uniform(-5, 5, 15)
         x2 = numpy.random.uniform(-5, 5, 15)
         a = numpy.array(x1 + 1j * x2, dtype=dtype).reshape(3, 5)
@@ -2328,6 +2342,9 @@ def test_norm_2D_complex(self, dtype, ord, axis, keepdims):
     )
     @pytest.mark.parametrize("keepdims", [True, False])
     def test_norm_ND(self, dtype, ord, axis, keepdims):
+        if is_cuda_device():
+            if ord in [-2, 2, "nuc"] and axis == (0, 1):
+                pytest.skip("SAT-7589")
         a = numpy.array(numpy.random.uniform(-5, 5, 120), dtype=dtype).reshape(
             2, 3, 4, 5
         )
@@ -2361,6 +2378,9 @@ def test_norm_ND(self, dtype, ord, axis, keepdims):
     )
     @pytest.mark.parametrize("keepdims", [True, False])
     def test_norm_ND_complex(self, dtype, ord, axis, keepdims):
+        if is_cuda_device():
+            if ord in [-2, 2, "nuc"] and axis == (0, 1):
+                pytest.skip("SAT-7589")
         x1 = numpy.random.uniform(-5, 5, 120)
         x2 = numpy.random.uniform(-5, 5, 120)
         a = numpy.array(x1 + 1j * x2, dtype=dtype).reshape(2, 3, 4, 5)
@@ -2394,6 +2414,9 @@ def test_norm_ND_complex(self, dtype, ord, axis, keepdims):
     )
     @pytest.mark.parametrize("keepdims", [True, False])
     def test_norm_usm_ndarray(self, dtype, ord, axis, keepdims):
+        if is_cuda_device():
+            if ord in [-2, 2, "nuc"] and axis in [(0, 1), (-2, -1)]:
+                pytest.skip("SAT-7589")
         a = numpy.array(numpy.random.uniform(-5, 5, 120), dtype=dtype).reshape(
             2, 3, 4, 5
         )
@@ -2473,6 +2496,9 @@ def test_norm_strided_ND(self, axis, stride):
     )
     @pytest.mark.parametrize("keepdims", [True, False])
     def test_matrix_norm(self, ord, keepdims):
+        if is_cuda_device():
+            if ord in [-2, 2, "nuc"]:
+                pytest.skip("SAT-7589")
         a = numpy.array(numpy.random.uniform(-5, 5, 15)).reshape(3, 5)
         ia = inp.array(a)
 
@@ -2570,6 +2596,12 @@ class TestQr:
         ids=["r", "raw", "complete", "reduced"],
     )
     def test_qr(self, dtype, shape, mode):
+        if (
+            is_cuda_device()
+            and mode in ["complete", "reduced"]
+            and shape in [(16, 16), (2, 2, 4)]
+        ):
+            pytest.skip("SAT-7589")
         # Set seed_value=81 to prevent
         # random generation of the input singular matrix
         a = generate_random_numpy_array(shape, dtype, seed_value=81)
@@ -2987,6 +3019,9 @@ def check_decomposition(
         ids=["(2,2)", "(3,4)", "(5,3)", "(16,16)"],
     )
     def test_svd(self, dtype, shape):
+        if is_cuda_device():
+            if shape == (3, 4):
+                pytest.skip("SAT-7589")
         a = numpy.arange(shape[0] * shape[1], dtype=dtype).reshape(shape)
         dp_a = inp.array(a)
 
@@ -3058,6 +3093,9 @@ class TestSvdvals:
         ids=["(3,5)", "(4,2)", "(2,3,3)", "(3,5,2)"],
     )
     def test_svdvals(self, dtype, shape):
+        if is_cuda_device():
+            if shape == (3, 5):
+                pytest.skip("SAT-7589")
         a = numpy.arange(numpy.prod(shape), dtype=dtype).reshape(shape)
         dp_a = inp.array(a)
 
@@ -3128,6 +3166,9 @@ def check_types_shapes(self, dp_B, np_B):
         ],
     )
     def test_pinv(self, dtype, shape):
+        if is_cuda_device():
+            if shape in [(3, 4), (2, 2, 4)]:
+                pytest.skip("SAT-7589")
         # Set seed_value=81 to prevent
         # random generation of the input singular matrix
         a = generate_random_numpy_array(shape, dtype, seed_value=81)

dpnp/tests/test_sycl_queue.py

@@ -16,6 +16,7 @@
     assert_dtype_allclose,
     generate_random_numpy_array,
     get_all_dtypes,
+    is_cuda_device,
     is_win_platform,
 )
 
@@ -1802,6 +1803,9 @@ def test_matrix_rank(data, tol, device):
     ids=["-1", "0", "1", "(0, 1)", "(-2, -1)", "None"],
 )
 def test_norm(device, ord, axis):
+    if is_cuda_device():
+        if axis in [(0, 1), (-2, -1)] and ord in [-2, 2, "nuc"]:
+            pytest.skip("SAT-7589")
     a = numpy.arange(120).reshape(2, 3, 4, 5)
     ia = dpnp.array(a, device=device)
     if (axis in [-1, 0, 1] and ord in ["nuc", "fro"]) or (
@@ -1901,6 +1905,9 @@ def test_qr(shape, mode, device):
     ],
 )
 def test_svd(shape, full_matrices, compute_uv, device):
+    if is_cuda_device():
+        if shape in [(1, 4), (2, 2, 3)]:
+            pytest.skip("SAT-7589")
     dtype = dpnp.default_float_type(device)
 
     count_elems = numpy.prod(shape)
@@ -2514,6 +2521,9 @@ def test_slogdet(shape, is_empty, device):
     ids=[device.filter_string for device in valid_devices],
 )
 def test_pinv(shape, hermitian, rcond_as_array, device):
+    if is_cuda_device():
+        if shape == (2, 2, 3):
+            pytest.skip("SAT-7589")
     dtype = dpnp.default_float_type(device)
     # Set seed_value=81 to prevent
     # random generation of the input singular matrix

dpnp/tests/test_usm_type.py

@@ -10,7 +10,11 @@
 import dpnp as dp
 from dpnp.dpnp_utils import get_usm_allocations
 
-from .helper import assert_dtype_allclose, generate_random_numpy_array
+from .helper import (
+    assert_dtype_allclose,
+    generate_random_numpy_array,
+    is_cuda_device,
+)
 
 list_of_usm_types = ["device", "shared", "host"]
 
@@ -542,6 +546,9 @@ def test_meshgrid(usm_type_x, usm_type_y):
     ids=["-1", "0", "1", "(0, 1)", "(-2, -1)", "None"],
 )
 def test_norm(usm_type, ord, axis):
+    if is_cuda_device():
+        if axis in [(0, 1), (-2, -1)] and ord in [-2, 2, "nuc"]:
+            pytest.skip("SAT-7589")
     ia = dp.arange(120, usm_type=usm_type).reshape(2, 3, 4, 5)
     if (axis in [-1, 0, 1] and ord in ["nuc", "fro"]) or (
         isinstance(axis, tuple) and ord == 3
@@ -862,6 +869,11 @@ def test_split(func, data1, usm_type):
 @pytest.mark.parametrize("usm_type", list_of_usm_types, ids=list_of_usm_types)
 @pytest.mark.parametrize("p", [None, -dp.inf, -2, -1, 1, 2, dp.inf, "fro"])
 def test_cond(usm_type, p):
+    if is_cuda_device():
+        if p in [None, -2, 2]:
+            pass
+        else:
+            pytest.skip("SAT-7589")
     ia = dp.arange(32, usm_type=usm_type).reshape(2, 4, 4)
 
     result = dp.linalg.cond(ia, p=p)
@@ -1443,6 +1455,9 @@ def test_inv(shape, is_empty, usm_type):
     ],
 )
 def test_svd(usm_type, shape, full_matrices_param, compute_uv_param):
+    if is_cuda_device():
+        if shape in [(1, 4), (2, 2, 3)]:
+            pytest.skip("SAT-7589")
     x = dp.ones(shape, usm_type=usm_type)
 
     if compute_uv_param:
@@ -1511,6 +1526,9 @@ def test_matrix_rank(data, tol, usm_type):
     ],
 )
 def test_pinv(shape, hermitian, usm_type):
+    if is_cuda_device():
+        if shape == (2, 2, 3):
+            pytest.skip("SAT-7589")
     a_np = generate_random_numpy_array(shape, hermitian=hermitian)
     a = dp.array(a_np, usm_type=usm_type)
 

dpnp/tests/third_party/cupy/linalg_tests/test_decomposition.py

@@ -7,6 +7,7 @@
 from dpnp.tests.helper import (
     has_support_aspect64,
     is_cpu_device,
+    is_cuda_device,
     is_win_platform,
 )
 from dpnp.tests.third_party.cupy import testing
@@ -256,13 +257,17 @@ def check_singular(self, shape, xp, dtype):
 
     @_condition.repeat(3, 10)
     def test_svd_rank2(self):
-        self.check_usv((3, 7))
+        # skip case where n < m on CUDA (SAT-7589)
+        if not is_cuda_device():
+            self.check_usv((3, 7))
         self.check_usv((2, 2))
         self.check_usv((7, 3))
 
     @_condition.repeat(3, 10)
     def test_svd_rank2_no_uv(self):
-        self.check_singular((3, 7))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_singular((3, 7))
         self.check_singular((2, 2))
         self.check_singular((7, 3))
 
@@ -288,8 +293,10 @@ def test_svd_rank2_empty_array_compute_uv_false(self, xp):
     )
     @_condition.repeat(3, 10)
     def test_svd_rank3(self):
-        self.check_usv((2, 3, 4))
-        self.check_usv((2, 3, 7))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_usv((2, 3, 4))
+            self.check_usv((2, 3, 7))
         self.check_usv((2, 4, 4))
         self.check_usv((2, 7, 3))
         self.check_usv((2, 4, 3))
@@ -303,12 +310,16 @@ def test_svd_rank3_loop(self):
         # This tests the loop-based batched gesvd on CUDA (_gesvd_batched)
         self.check_usv((2, 64, 64))
         self.check_usv((2, 64, 32))
-        self.check_usv((2, 32, 64))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_usv((2, 32, 64))
 
     @_condition.repeat(3, 10)
     def test_svd_rank3_no_uv(self):
-        self.check_singular((2, 3, 4))
-        self.check_singular((2, 3, 7))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_singular((2, 3, 4))
+            self.check_singular((2, 3, 7))
         self.check_singular((2, 4, 4))
         self.check_singular((2, 7, 3))
         self.check_singular((2, 4, 3))
@@ -318,7 +329,9 @@ def test_svd_rank3_no_uv_loop(self):
         # This tests the loop-based batched gesvd on CUDA (_gesvd_batched)
         self.check_singular((2, 64, 64))
         self.check_singular((2, 64, 32))
-        self.check_singular((2, 32, 64))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_singular((2, 32, 64))
 
     @testing.with_requires("numpy>=1.16")
     def test_svd_rank3_empty_array(self):
@@ -350,8 +363,10 @@ def test_svd_rank3_empty_array_compute_uv_false2(self, xp):
     )
     @_condition.repeat(3, 10)
     def test_svd_rank4(self):
-        self.check_usv((2, 2, 3, 4))
-        self.check_usv((2, 2, 3, 7))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_usv((2, 2, 3, 4))
+            self.check_usv((2, 2, 3, 7))
         self.check_usv((2, 2, 4, 4))
         self.check_usv((2, 2, 7, 3))
         self.check_usv((2, 2, 4, 3))
@@ -365,12 +380,16 @@ def test_svd_rank4_loop(self):
         # This tests the loop-based batched gesvd on CUDA (_gesvd_batched)
         self.check_usv((3, 2, 64, 64))
         self.check_usv((3, 2, 64, 32))
-        self.check_usv((3, 2, 32, 64))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_usv((3, 2, 32, 64))
 
     @_condition.repeat(3, 10)
     def test_svd_rank4_no_uv(self):
-        self.check_singular((2, 2, 3, 4))
-        self.check_singular((2, 2, 3, 7))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_singular((2, 2, 3, 4))
+            self.check_singular((2, 2, 3, 7))
         self.check_singular((2, 2, 4, 4))
         self.check_singular((2, 2, 7, 3))
         self.check_singular((2, 2, 4, 3))
@@ -380,7 +399,9 @@ def test_svd_rank4_no_uv_loop(self):
         # This tests the loop-based batched gesvd on CUDA (_gesvd_batched)
         self.check_singular((3, 2, 64, 64))
         self.check_singular((3, 2, 64, 32))
-        self.check_singular((3, 2, 32, 64))
+        # SAT-7589
+        if not is_cuda_device():
+            self.check_singular((3, 2, 32, 64))
 
     @testing.with_requires("numpy>=1.16")
     def test_svd_rank4_empty_array(self):
@@ -398,7 +419,14 @@ def test_svd_rank4_empty_array(self):
 )
 class TestQRDecomposition(unittest.TestCase):
     @testing.for_dtypes("fdFD")
+    # skip cases with 'complete' and 'reduce' modes on CUDA (SAT-7589)
     def check_mode(self, array, mode, dtype):
+        if (
+            is_cuda_device()
+            and array.size > 0
+            and mode in ["complete", "reduced"]
+        ):
+            return
         a_cpu = numpy.asarray(array, dtype=dtype)
         a_gpu = cupy.asarray(array, dtype=dtype)
         result_gpu = cupy.linalg.qr(a_gpu, mode=mode)

dpnp/tests/third_party/cupy/linalg_tests/test_norms.py

@@ -4,7 +4,7 @@
 import pytest
 
 import dpnp as cupy
-from dpnp.tests.helper import is_cpu_device
+from dpnp.tests.helper import is_cpu_device, is_cuda_device
 from dpnp.tests.third_party.cupy import testing
 
 
@@ -62,6 +62,12 @@ class TestNorm(unittest.TestCase):
     @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-4, type_check=False)
     # since dtype of sum is different in dpnp and NumPy, type_check=False
     def test_norm(self, xp, dtype):
+        if (
+            is_cuda_device()
+            and self.shape == (1, 2)
+            and self.ord in [-2, 2, "nuc"]
+        ):
+            pytest.skip("SAT-7589")
         a = testing.shaped_arange(self.shape, xp, dtype)
         res = xp.linalg.norm(a, self.ord, self.axis, self.keepdims)
         if xp == numpy and not isinstance(res, numpy.ndarray):