Fix torch svd

ivy/functional/backends/jax/linear_algebra.py

@@ -361,7 +361,7 @@ def svd(
     x: JaxArray, /, *, compute_uv: bool = True, full_matrices: bool = True
 ) -> Union[JaxArray, Tuple[JaxArray, ...]]:
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
+        results = namedtuple("svd", ['U', 'S', 'Vh'])
         U, D, VT = jnp.linalg.svd(x, full_matrices=full_matrices, compute_uv=compute_uv)
         return results(U, D, VT)
     else:

ivy/functional/backends/numpy/linear_algebra.py

@@ -291,7 +291,7 @@ def svd(
     x: np.ndarray, /, *, compute_uv: bool = True, full_matrices: bool = True
 ) -> Union[np.ndarray, Tuple[np.ndarray, ...]]:
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
+        results = namedtuple("svd", ['U', 'S', 'Vh'])
         U, D, VT = np.linalg.svd(x, full_matrices=full_matrices, compute_uv=compute_uv)
         return results(U, D, VT)
     else:

ivy/functional/backends/paddle/linear_algebra.py

@@ -521,7 +521,7 @@ def svd(
 ) -> Union[paddle.Tensor, Tuple[paddle.Tensor, ...]]:
     ret = paddle.linalg.svd(x, full_matrices=full_matrices)
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
+        results = namedtuple("svd", ['U', 'S', 'Vh'])
         return results(*ret)
     else:
         results = namedtuple("svd", "S")

ivy/functional/backends/tensorflow/linear_algebra.py

@@ -545,8 +545,7 @@ def svd(
     compute_uv: bool = True,
 ) -> Union[Union[tf.Tensor, tf.Variable], Tuple[Union[tf.Tensor, tf.Variable], ...]]:
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
-
+        results = namedtuple("svd", ['U', 'S', 'Vh'])
         batch_shape = tf.shape(x)[:-2]
         num_batch_dims = len(batch_shape)
         transpose_dims = list(range(num_batch_dims)) + [

ivy/functional/backends/torch/linear_algebra.py

@@ -414,16 +414,13 @@ def svd(
     x: torch.Tensor, /, *, full_matrices: bool = True, compute_uv: bool = True
 ) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]:
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
-
+        results = namedtuple("svd", ['U', 'S', 'Vh'])
         U, D, VT = torch.linalg.svd(x, full_matrices=full_matrices)
         return results(U, D, VT)
     else:
         results = namedtuple("svd", "S")
-        svd = torch.linalg.svd(x, full_matrices=full_matrices)
-        # torch.linalg.svd returns a tuple with U, S, and Vh
-        D = svd[1]
-        return results(D)
+        s = torch.linalg.svdvals(x)
+        return results(s)
 
 
 @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version)

ivy/functional/frontends/torch/blas_and_lapack_ops.py

@@ -2,6 +2,7 @@
 import ivy
 from ivy.func_wrapper import with_unsupported_dtypes
 import ivy.functional.frontends.torch as torch_frontend
+from collections import namedtuple
 from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back
 
 
@@ -191,11 +192,17 @@ def slogdet(A, *, out=None):
 
 @to_ivy_arrays_and_back
 def svd(input, some=True, compute_uv=True, *, out=None):
-    # TODO: add compute_uv
-    if some:
-        ret = ivy.svd(input, full_matrices=False)
+    retu = ivy.svd(input, full_matrices=not some, compute_uv=compute_uv)
+    results = namedtuple("svd", ['U', 'S', 'V'])
+    if compute_uv:
+        ret = results(retu[0], retu[1], ivy.adjoint(retu[2]))
     else:
-        ret = ivy.svd(input, full_matrices=True)
+        shape = list(input.shape)
+        shape1 = shape
+        shape2 = shape
+        shape1[-2] = shape[-1]
+        shape2[-1] = shape[-2]
+        ret = results(ivy.zeros(shape1, device=input.device, dtype=input.dtype), retu[0], ivy.zeros(shape2, device=input.device, dtype=input.dtype))
     if ivy.exists(out):
         return ivy.inplace_update(out, ret)
     return ret

ivy/functional/frontends/torch/linalg.py

@@ -326,8 +326,11 @@ def solve_ex(A, B, *, left=True, check_errors=False, out=None):
     {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch"
 )
 def svd(A, /, *, full_matrices=True, driver=None, out=None):
-    # TODO: add handling for driver and out
-    return ivy.svd(A, compute_uv=True, full_matrices=full_matrices)
+    # TODO: add handling for driver
+    ret = ivy.svd(A, compute_uv=True, full_matrices=full_matrices)
+    if ivy.exists(out):
+        return ivy.inplace_update(out, ret)
+    return ret
 
 
 @to_ivy_arrays_and_back

ivy/functional/ivy/linear_algebra.py

@@ -2130,15 +2130,12 @@ def svd(
         If ``True`` then left and right singular vectors will be computed and returned
         in ``U`` and ``Vh``, respectively. Otherwise, only the singular values will be
         computed, which can be significantly faster.
-    .. note::
-        with backend set as torch, svd with still compute left and right singular
-        vectors irrespective of the value of compute_uv, however Ivy will still
-        only return the singular values.
 
     Returns
     -------
     .. note::
         once complex numbers are supported, each square matrix must be Hermitian.
+        In addition, the return will be a namedtuple ``(S)`` when compute_uv is ``False``
 
     ret
         a namedtuple ``(U, S, Vh)`` whose

ivy_tests/test_ivy/test_frontends/test_torch/test_blas_and_lapack_ops.py

@@ -4,6 +4,7 @@
 from hypothesis import strategies as st, assume
 
 # local
+import ivy
 import ivy_tests.test_ivy.helpers as helpers
 from ivy_tests.test_ivy.helpers import handle_frontend_test
 from ivy_tests.test_ivy.helpers.hypothesis_helpers.general_helpers import (
@@ -848,37 +849,62 @@ def test_torch_qr(
 @handle_frontend_test(
     fn_tree="torch.svd",
     dtype_and_x=helpers.dtype_and_values(
-        available_dtypes=helpers.get_dtypes("float", index=1),
-        min_num_dims=3,
-        max_num_dims=5,
-        min_dim_size=2,
-        max_dim_size=5,
+        available_dtypes=helpers.get_dtypes("float"),
+        min_value=0,
+        max_value=10,
+        shape=helpers.ints(min_value=2, max_value=5).map(lambda x: (x, x)),
     ),
     some=st.booleans(),
-    compute=st.booleans(),
+    compute_uv=st.booleans(),
 )
 def test_torch_svd(
     dtype_and_x,
     some,
-    compute,
-    on_device,
-    fn_tree,
+    compute_uv,
     frontend,
     test_flags,
+    fn_tree,
     backend_fw,
+    on_device,
 ):
-    dtype, x = dtype_and_x
-    helpers.test_frontend_function(
-        input_dtypes=dtype,
+    input_dtype, x = dtype_and_x
+    x = np.asarray(x[0], dtype=input_dtype[0])
+    # make symmetric positive definite beforehand
+    x = np.matmul(x.T, x) + np.identity(x.shape[0]) * 1e-3
+    ret, frontend_ret = helpers.test_frontend_function(
+        input_dtypes=input_dtype,
         backend_to_test=backend_fw,
         frontend=frontend,
         test_flags=test_flags,
         fn_tree=fn_tree,
         on_device=on_device,
-        input=x[0],
+        test_values=False,
+        input = x,
         some=some,
-        compute_uv=compute,
+        compute_uv=compute_uv,
     )
+    ret = [ivy.to_numpy(x) for x in ret]
+    frontend_ret = [np.asarray(x) for x in frontend_ret]
+
+    u, s, v = ret
+    frontend_u, frontend_s, frontend_v = frontend_ret
+
+    if compute_uv:
+        helpers.assert_all_close(
+            ret_np=frontend_u @ np.diag(frontend_s) @ frontend_v.T,
+            ret_from_gt_np=u @ np.diag(s) @ v.T,
+            atol=1e-04,
+            backend=backend_fw,
+            ground_truth_backend=frontend,
+        )
+    else:
+        helpers.assert_all_close(
+            ret_np=frontend_s,
+            ret_from_gt_np=s,
+            atol=1e-04,
+            backend=backend_fw,
+            ground_truth_backend=frontend,
+        )
 
 
 @handle_frontend_test(

ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py

@@ -1247,7 +1247,15 @@ def test_torch_solve_ex(
 # svd
 @handle_frontend_test(
     fn_tree="torch.linalg.svd",
-    dtype_and_x=_get_dtype_and_matrix(square=True),
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_value=0,
+        max_value=10,
+        min_num_dims=2,
+        max_num_dims=5,
+        min_dim_size=1,
+        max_dim_size=5,
+    ),
     full_matrices=st.booleans(),
 )
 def test_torch_svd(
@@ -1272,25 +1280,30 @@ def test_torch_svd(
         fn_tree=fn_tree,
         on_device=on_device,
         test_values=False,
-        atol=1e-03,
-        rtol=1e-05,
         A=x,
         full_matrices=full_matrices,
     )
     ret = [ivy.to_numpy(x) for x in ret]
     frontend_ret = [np.asarray(x) for x in frontend_ret]
-
     u, s, vh = ret
     frontend_u, frontend_s, frontend_vh = frontend_ret
+    if full_matrices:
+        helpers.assert_all_close(
+            ret_np=frontend_u[...,:frontend_s.shape[0]] @ np.diag(frontend_s) @ frontend_vh.T,
+            ret_from_gt_np=u[...,:s.shape[0]] @ np.diag(s) @ vh.T,
+            atol=1e-04,
+            backend=backend_fw,
+            ground_truth_backend=frontend,
+        )
+    else:
+        helpers.assert_all_close(
+            ret_np=frontend_u @ np.diag(frontend_s) @ frontend_vh.T,
+            ret_from_gt_np=u @ np.diag(s) @ vh.T,
+            atol=1e-04,
+            backend=backend_fw,
+            ground_truth_backend=frontend,
+        )
 
-    assert_all_close(
-        ret_np=u @ np.diag(s) @ vh,
-        ret_from_gt_np=frontend_u @ np.diag(frontend_s) @ frontend_vh,
-        rtol=1e-2,
-        atol=1e-2,
-        ground_truth_backend=frontend,
-        backend=backend_fw,
-    )
 
 
 # svdvals