torchsparsegradutils 0.2.4__tar.gz → 0.2.5__tar.gz

{torchsparsegradutils-0.2.4/torchsparsegradutils.egg-info → torchsparsegradutils-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: torchsparsegradutils
-Version: 0.2.4
+Version: 0.2.5
 Summary: A collection of utility functions to work with PyTorch sparse tensors
 Author-email: CAI4CAI research group <contact@cai4cai.uk>
 License-Expression: Apache-2.0
@@ -239,15 +239,18 @@ batch_size, event_size = 2, 1000
 loc = torch.zeros(batch_size, event_size)
 
 # Example 1: LDL^T parameterization (numerically stable for precision matrices)
-# Create sparse lower triangular matrix (unit triangular, no diagonal)
+# Create sparse lower triangular matrix (strictly lower triangular, no diagonal)
+
 scale_tril = rand_sparse_tri(
     (batch_size, event_size, event_size),
-    nnz=5000,  # 5000 non-zeros for 1M parameters (0.5% sparsity)
+    nnz=5000,  # 5000 non-zeros for 1000x1000 dense matrix (99.5% sparsity)
     layout=torch.sparse_csr,
     upper=False,
-    unit_triangular=True  # Unit triangular for LDL^T
+    strict=True  # Strict triangular (exclude diagonal)
 )
 
+scale_tril.requires_grad_(True)
+
 # Diagonal component for LDL^T parameterization
 diagonal = torch.ones(batch_size, event_size) * 0.5
 
@@ -255,7 +258,7 @@ diagonal = torch.ones(batch_size, event_size) * 0.5
 dist_ldlt = SparseMultivariateNormal(
     loc=loc,
     diagonal=diagonal,
-    scale_tril=scale_tril  # Unit lower triangular
+    scale_tril=scale_tril  # Strictly lower triangular
 )
 
 # Example 2: LL^T parameterization (standard Cholesky)
@@ -264,7 +267,7 @@ scale_tril_chol = rand_sparse_tri(
     nnz=5000,
     layout=torch.sparse_csr,
     upper=False,
-    unit_triangular=False  # Include diagonal for LL^T
+    strict=False  # Include diagonal
 )
 
 # Create distribution with LL^T parameterization
@@ -279,7 +282,7 @@ precision_tril = rand_sparse_tri(
     nnz=5000,
     layout=torch.sparse_csr,
     upper=False,
-    unit_triangular=True
+    strict=True
 )
 
 precision_diagonal = torch.ones(batch_size, event_size) * 2.0
@@ -287,7 +290,7 @@ precision_diagonal = torch.ones(batch_size, event_size) * 2.0
 dist_precision = SparseMultivariateNormal(
     loc=loc,
     diagonal=precision_diagonal,
-    precision_tril=precision_tril  # Unit triangular precision factor
+    precision_tril=precision_tril  # Strictly triangular precision factor
 )
 
 # Sample with gradient support

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/README.md

@@ -192,15 +192,18 @@ batch_size, event_size = 2, 1000
 loc = torch.zeros(batch_size, event_size)
 
 # Example 1: LDL^T parameterization (numerically stable for precision matrices)
-# Create sparse lower triangular matrix (unit triangular, no diagonal)
+# Create sparse lower triangular matrix (strictly lower triangular, no diagonal)
+
 scale_tril = rand_sparse_tri(
     (batch_size, event_size, event_size),
-    nnz=5000,  # 5000 non-zeros for 1M parameters (0.5% sparsity)
+    nnz=5000,  # 5000 non-zeros for 1000x1000 dense matrix (99.5% sparsity)
     layout=torch.sparse_csr,
     upper=False,
-    unit_triangular=True  # Unit triangular for LDL^T
+    strict=True  # Strict triangular (exclude diagonal)
 )
 
+scale_tril.requires_grad_(True)
+
 # Diagonal component for LDL^T parameterization
 diagonal = torch.ones(batch_size, event_size) * 0.5
 
@@ -208,7 +211,7 @@ diagonal = torch.ones(batch_size, event_size) * 0.5
 dist_ldlt = SparseMultivariateNormal(
     loc=loc,
     diagonal=diagonal,
-    scale_tril=scale_tril  # Unit lower triangular
+    scale_tril=scale_tril  # Strictly lower triangular
 )
 
 # Example 2: LL^T parameterization (standard Cholesky)
@@ -217,7 +220,7 @@ scale_tril_chol = rand_sparse_tri(
     nnz=5000,
     layout=torch.sparse_csr,
     upper=False,
-    unit_triangular=False  # Include diagonal for LL^T
+    strict=False  # Include diagonal
 )
 
 # Create distribution with LL^T parameterization
@@ -232,7 +235,7 @@ precision_tril = rand_sparse_tri(
     nnz=5000,
     layout=torch.sparse_csr,
     upper=False,
-    unit_triangular=True
+    strict=True
 )
 
 precision_diagonal = torch.ones(batch_size, event_size) * 2.0
@@ -240,7 +243,7 @@ precision_diagonal = torch.ones(batch_size, event_size) * 2.0
 dist_precision = SparseMultivariateNormal(
     loc=loc,
     diagonal=precision_diagonal,
-    precision_tril=precision_tril  # Unit triangular precision factor
+    precision_tril=precision_tril  # Strictly triangular precision factor
 )
 
 # Sample with gradient support

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/docs/source/conf.py

@@ -15,8 +15,8 @@ sys.path.insert(0, os.path.abspath("../../"))
 project = "torchsparsegradutils"
 copyright = "2026, CAI4CAI research group"
 author = "CAI4CAI research group"
-release = "0.2.4"
-version = "0.2.4"
+release = "0.2.5"
+version = "0.2.5"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "torchsparsegradutils"
-version = "0.2.4"
+version = "0.2.5"
 description = "A collection of utility functions to work with PyTorch sparse tensors"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -105,6 +105,12 @@ testpaths = [
 pythonpath = [
     "torchsparsegradutils/tests",
 ]
+# Fail tests when deprecated upstream APIs are exercised outside intentional compatibility paths.
+filterwarnings = [
+    'error:torch\.norm is deprecated.*:UserWarning',
+    'error:torch\.triangular_solve is deprecated.*:UserWarning',
+    'error:.*torch\.jit\.script.*is deprecated.*:DeprecationWarning',
+]
 doctest_optionflags = [
     "NORMALIZE_WHITESPACE",
     "IGNORE_EXCEPTION_DETAIL",

torchsparsegradutils-0.2.5/torchsparsegradutils/_compat.py

@@ -0,0 +1,48 @@
+"""Compatibility helpers for PyTorch APIs without feature-equivalent replacements."""
+
+import warnings
+
+import torch
+
+
+def linalg_solve_triangular_compat(
+    A: torch.Tensor,
+    B: torch.Tensor,
+    *,
+    upper: bool,
+    unitriangular: bool = False,
+    transpose: bool = False,
+) -> torch.Tensor:
+    """Solve a triangular system with the appropriate dense or sparse backend.
+
+    Dense coefficient matrices use ``torch.linalg.solve_triangular``. Sparse
+    matrices continue to use the isolated legacy call because the replacement
+    API does not support the sparse layouts required by this package. See
+    https://github.com/pytorch/pytorch/issues/87358 for upstream sparse feature
+    parity tracking.
+    """
+    if A.layout == torch.strided:
+        if transpose:
+            A = A.transpose(-2, -1)
+            upper = not upper
+
+        return torch.linalg.solve_triangular(
+            A,
+            B,
+            upper=upper,
+            unitriangular=unitriangular,
+        )
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            message=r"torch\.triangular_solve is deprecated.*",
+            category=UserWarning,
+        )
+        return torch.triangular_solve(
+            B,
+            A,
+            upper=upper,
+            transpose=transpose,
+            unitriangular=unitriangular,
+        ).solution

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/benchmarks/sparse_generic_solve_rand.py

@@ -225,8 +225,8 @@ def run_sparse_generic_solve_benchmark():
                                 else:
                                     residual = A_sparse @ x - B
 
-                                resnorm = torch.norm(residual).cpu().item()
-                                B_norm = torch.norm(B).cpu().item()
+                                resnorm = torch.linalg.vector_norm(residual).cpu().item()
+                                B_norm = torch.linalg.vector_norm(B).cpu().item()
                                 relative_resnorm = resnorm / B_norm if B_norm > 0 else 0.0
 
                             # Print result with residual norm

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/benchmarks/sparse_generic_solve_suite.py

@@ -201,10 +201,9 @@ def run_sparse_solve_benchmark():
                         with torch.no_grad():
                             x = alg_fn(A_sparse, B)
                             residual = A_sparse @ x - B
-                            resnorm = torch.norm(residual).cpu().item()
-                            relative_resnorm = (
-                                resnorm / torch.norm(B).cpu().item() if torch.norm(B).cpu().item() > 0 else 0.0
-                            )
+                            resnorm = torch.linalg.vector_norm(residual).cpu().item()
+                            B_norm = torch.linalg.vector_norm(B).cpu().item()
+                            relative_resnorm = resnorm / B_norm if B_norm > 0 else 0.0
 
                         # Print result with residual norm
                         print_result_row(

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/benchmarks/sparse_triangular_solve_rand.py

@@ -27,6 +27,7 @@ from cupyx.scipy.sparse.linalg._solve import spsolve_triangular
 from tqdm import tqdm
 
 from torchsparsegradutils import sparse_triangular_solve
+from torchsparsegradutils._compat import linalg_solve_triangular_compat
 from torchsparsegradutils.cupy.cupy_sparse_solve import sparse_solve_c4t
 from torchsparsegradutils.utils import rand_sparse, rand_sparse_tri
 
@@ -58,16 +59,19 @@ LAYOUTS = [torch.sparse_coo, torch.sparse_csr]
 
 ALGORITHMS = [
     (
-        "dense.triangular_solve",
-        lambda A, B: torch.triangular_solve(
-            B, A.to_dense(), upper=UPPER, unitriangular=UNITRIANGULAR, transpose=TRANSPOSE
-        ).solution,
+        "dense.linalg.solve_triangular",
+        lambda A, B: torch.linalg.solve_triangular(
+            A.to_dense().transpose(-2, -1) if TRANSPOSE else A.to_dense(),
+            B,
+            upper=not UPPER if TRANSPOSE else UPPER,
+            unitriangular=UNITRIANGULAR,
+        ),
     ),
     (
-        "torch_triangular_solve",
-        lambda A, B: torch.triangular_solve(
-            B, A, upper=UPPER, unitriangular=UNITRIANGULAR, transpose=TRANSPOSE
-        ).solution,
+        "linalg_solve_triangular_compat",
+        lambda A, B: linalg_solve_triangular_compat(
+            A, B, upper=UPPER, unitriangular=UNITRIANGULAR, transpose=TRANSPOSE
+        ),
     ),
     (
         "sparse_triangular_solve",
@@ -153,8 +157,8 @@ def run_sparse_triangular_solve_benchmark():
                             with torch.no_grad():
                                 x = alg_fn(A_sparse, B)
                                 residual = A_sparse @ x - B
-                                resnorm = torch.norm(residual).cpu().item()
-                                relative_resnorm = resnorm / torch.norm(B).cpu().item()
+                                resnorm = torch.linalg.vector_norm(residual).cpu().item()
+                                relative_resnorm = resnorm / torch.linalg.vector_norm(B).cpu().item()
 
                             # # Calculate residual norm for solution accuracy
                             # with torch.no_grad():
@@ -165,8 +169,8 @@ def run_sparse_triangular_solve_benchmark():
                             #     else:
                             #         Ax = A_sparse @ x
                             #     residual = Ax - B
-                            #     resnorm = torch.norm(residual).cpu().item()
-                            #     relative_resnorm = resnorm / torch.norm(B).cpu().item()
+                            #     resnorm = torch.linalg.vector_norm(residual).cpu().item()
+                            #     relative_resnorm = resnorm / torch.linalg.vector_norm(B).cpu().item()
 
                             # Print result with residual norm
                             print_result_row(

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/benchmarks/sparse_triangular_solve_suitesparse.py

@@ -34,6 +34,7 @@ from cupyx.scipy.sparse.linalg._solve import spsolve_triangular
 from tqdm import tqdm
 
 from torchsparsegradutils import sparse_triangular_solve
+from torchsparsegradutils._compat import linalg_solve_triangular_compat
 from torchsparsegradutils.cupy.cupy_sparse_solve import sparse_solve_c4t
 
 # from jax.lax.linalg import triangular_solve  # NOTE: jax doesn't have a sparse triangular solve
@@ -57,16 +58,19 @@ LAYOUTS = [torch.sparse_coo, torch.sparse_csr]
 
 ALGORITHMS = [
     (
-        "dense.triangular_solve",
-        lambda A, B: torch.triangular_solve(
-            B, A.to_dense(), upper=UPPER, unitriangular=UNITRIANGULAR, transpose=TRANSPOSE
-        ).solution,
+        "dense.linalg.solve_triangular",
+        lambda A, B: torch.linalg.solve_triangular(
+            A.to_dense().transpose(-2, -1) if TRANSPOSE else A.to_dense(),
+            B,
+            upper=not UPPER if TRANSPOSE else UPPER,
+            unitriangular=UNITRIANGULAR,
+        ),
     ),
     (
-        "torch_triangular_solve",
-        lambda A, B: torch.triangular_solve(
-            B, A, upper=UPPER, unitriangular=UNITRIANGULAR, transpose=TRANSPOSE
-        ).solution,
+        "linalg_solve_triangular_compat",
+        lambda A, B: linalg_solve_triangular_compat(
+            A, B, upper=UPPER, unitriangular=UNITRIANGULAR, transpose=TRANSPOSE
+        ),
     ),
     (
         "sparse_triangular_solve",
@@ -185,10 +189,9 @@ def run_triangular_solve_benchmark():
                             # Use the triangular matrix A_sparse (not A_full) for residual calculation
                             # This ensures the residual is computed correctly for the actual triangular system solved
                             residual = A_sparse @ x - B
-                            resnorm = torch.norm(residual).cpu().item()
-                            relative_resnorm = (
-                                resnorm / torch.norm(B).cpu().item() if torch.norm(B).cpu().item() > 0 else 0.0
-                            )
+                            resnorm = torch.linalg.vector_norm(residual).cpu().item()
+                            B_norm = torch.linalg.vector_norm(B).cpu().item()
+                            relative_resnorm = resnorm / B_norm if B_norm > 0 else 0.0
 
                         # Print result
                         print_result_row(

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/sparse_solve.py

@@ -3,6 +3,7 @@ from typing import Callable, Optional, cast
 
 import torch
 
+from torchsparsegradutils._compat import linalg_solve_triangular_compat
 from torchsparsegradutils.utils import convert_coo_to_csr, sparse_block_diag, sparse_block_diag_split, stack_csr
 
 
@@ -154,7 +155,7 @@ class SparseTriangularSolve(torch.autograd.Function):
     See Also
     --------
     sparse_triangular_solve : User-facing function that calls this autograd function.
-    torch.triangular_solve : PyTorch's native triangular solver.
+    torch.linalg.solve_triangular : PyTorch's native dense triangular solver.
     """
 
     @staticmethod
@@ -177,11 +178,9 @@ class SparseTriangularSolve(torch.autograd.Function):
             A = convert_coo_to_csr(A)  # NOTE: triangular solve doesn't work with sparse coo
             ctx.csr = False
 
-        # NOTE: DEPRECATED: Check if a workaround for https://github.com/pytorch/pytorch/issues/88890 is needed
-
-        x = torch.triangular_solve(
-            B.detach(), A.detach(), upper=upper, unitriangular=unitriangular, transpose=transpose
-        ).solution
+        x = linalg_solve_triangular_compat(
+            A.detach(), B.detach(), upper=upper, unitriangular=unitriangular, transpose=transpose
+        )
 
         x.requires_grad = grad_flag
         ctx.save_for_backward(A, x.detach())
@@ -199,11 +198,10 @@ class SparseTriangularSolve(torch.autograd.Function):
         A, x = ctx.saved_tensors
 
         # Backprop rule: gradB = A^{-T} grad
-        # NOTE: DEPRECATED: Check if a workaround for https://github.com/pytorch/pytorch/issues/88890 is needed
 
-        gradB = torch.triangular_solve(
-            grad, A, upper=ctx.upper, transpose=not ctx.transpose, unitriangular=ctx.unitriangular
-        ).solution
+        gradB = linalg_solve_triangular_compat(
+            A, grad, upper=ctx.upper, transpose=not ctx.transpose, unitriangular=ctx.unitriangular
+        )
 
         # The gradient with respect to the matrix A seen as a dense matrix would
         # lead to a backprop rule as follows

torchsparsegradutils-0.2.5/torchsparsegradutils/tests/test_deprecated_torch_apis.py

@@ -0,0 +1,62 @@
+"""Regression checks for deprecated upstream PyTorch APIs."""
+
+import ast
+import re
+from pathlib import Path
+
+REPOSITORY_ROOT = Path(__file__).parents[2]
+PACKAGE_ROOT = REPOSITORY_ROOT / "torchsparsegradutils"
+COMPATIBILITY_MODULE = Path("_compat.py")
+DEPRECATED_DOCUMENTATION_NORM = re.compile(r"(?<![\w.])torch\.norm\s*\(")
+
+
+def attribute_name(node):
+    parts = []
+    while isinstance(node, ast.Attribute):
+        parts.append(node.attr)
+        node = node.value
+    if isinstance(node, ast.Name):
+        parts.append(node.id)
+    return ".".join(reversed(parts))
+
+
+def test_deprecated_torch_calls_are_not_reintroduced():
+    violations = []
+    compatibility_calls = []
+
+    for path in PACKAGE_ROOT.rglob("*.py"):
+        relative_path = path.relative_to(PACKAGE_ROOT)
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+
+        for node in ast.walk(tree):
+            location = f"{relative_path}:{getattr(node, 'lineno', '?')}"
+            if isinstance(node, ast.Attribute) and attribute_name(node) == "torch.jit.script":
+                violations.append(location)
+
+            if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
+                continue
+
+            call_name = attribute_name(node.func)
+            if call_name == "torch.norm":
+                violations.append(location)
+            elif call_name == "torch.triangular_solve":
+                if relative_path == COMPATIBILITY_MODULE:
+                    compatibility_calls.append(location)
+                else:
+                    violations.append(location)
+
+    assert not violations, "Deprecated PyTorch APIs found:\n" + "\n".join(violations)
+    assert len(compatibility_calls) == 1, "Expected one isolated sparse triangular compatibility call"
+
+
+def test_documentation_does_not_use_deprecated_norm_apis():
+    violations = []
+    documentation_paths = [REPOSITORY_ROOT / "README.md"]
+    documentation_paths.extend((REPOSITORY_ROOT / "docs").rglob("*.md"))
+    documentation_paths.extend((REPOSITORY_ROOT / "docs").rglob("*.rst"))
+
+    for path in documentation_paths:
+        if DEPRECATED_DOCUMENTATION_NORM.search(path.read_text(encoding="utf-8")):
+            violations.append(str(path.relative_to(REPOSITORY_ROOT)))
+
+    assert not violations, "Deprecated norm examples found:\n" + "\n".join(violations)

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/tests/test_integration_pairwise_sparse_mvn.py

@@ -360,7 +360,7 @@ def run_forward_backward_iterations(
 
         # Record gradient statistics
         if params.grad is not None:
-            grad_norm = params.grad.norm().item()
+            grad_norm = torch.linalg.vector_norm(params.grad).item()
             grad_max = params.grad.abs().max().item()
             grad_mean = params.grad.abs().mean().item()
 
@@ -505,7 +505,7 @@ def test_integration_gradient_flow_consistency_2d(
         # Backward pass
         loss.backward()
 
-        gradient_norms.append(params.grad.norm().item())
+        gradient_norms.append(torch.linalg.vector_norm(params.grad).item())
 
         # Zero gradients
         params.grad.zero_()
@@ -551,7 +551,7 @@ def test_integration_gradient_flow_consistency_3d(
         # Backward pass
         loss.backward()
 
-        gradient_norms.append(params.grad.norm().item())
+        gradient_norms.append(torch.linalg.vector_norm(params.grad).item())
 
         # Zero gradients
         params.grad.zero_()
@@ -591,7 +591,7 @@ def test_integration_parameter_optimization_2d(
 
     # Optimization loop
     optimizer = torch.optim.Adam([params], lr=0.01)
-    initial_param_norm = params.norm().item()
+    initial_param_norm = torch.linalg.vector_norm(params).item()
 
     for _ in range(10):
         optimizer.zero_grad()
@@ -611,7 +611,7 @@ def test_integration_parameter_optimization_2d(
         optimizer.step()
 
     # Check that parameters changed
-    final_param_norm = params.norm().item()
+    final_param_norm = torch.linalg.vector_norm(params).item()
     param_change = abs(final_param_norm - initial_param_norm) / initial_param_norm
 
     assert param_change > 0.01, f"Parameters barely changed: {param_change:.6f}"
@@ -642,7 +642,7 @@ def test_integration_parameter_optimization_3d(
 
     # Optimization loop
     optimizer = torch.optim.Adam([params], lr=0.01)
-    initial_param_norm = params.norm().item()
+    initial_param_norm = torch.linalg.vector_norm(params).item()
 
     for _ in range(10):
         optimizer.zero_grad()
@@ -662,7 +662,7 @@ def test_integration_parameter_optimization_3d(
         optimizer.step()
 
     # Check that parameters changed
-    final_param_norm = params.norm().item()
+    final_param_norm = torch.linalg.vector_norm(params).item()
     param_change = abs(final_param_norm - initial_param_norm) / initial_param_norm
 
     assert param_change > 0.01, f"Parameters barely changed: {param_change:.6f}"

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/tests/test_linear_cg.py

@@ -10,7 +10,7 @@ def test_cg():
     # SPD matrix
     matrix = torch.randn(size, size, dtype=torch.float64)
     matrix = matrix.matmul(matrix.mT)
-    matrix.div_(matrix.norm()).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
+    matrix.div_(torch.linalg.vector_norm(matrix)).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
     # single RHS
     rhs = torch.randn(size, dtype=torch.float64)
     solves = linear_cg(matrix.matmul, rhs=rhs, max_iter=size)
@@ -36,7 +36,7 @@ def test_cg_with_tridiag():
     size = 10
     matrix = torch.randn(size, size, dtype=torch.float64)
     matrix = matrix.matmul(matrix.mT)
-    matrix.div_(matrix.norm()).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
+    matrix.div_(torch.linalg.vector_norm(matrix)).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
     rhs = torch.randn(size, 50, dtype=torch.float64)
     solves, t_mats = linear_cg(
         matrix.matmul, rhs=rhs, n_tridiag=5, max_tridiag_iter=10, max_iter=size, tolerance=0, eps=1e-15
@@ -57,7 +57,7 @@ def test_batch_cg(batch):
     shape = (batch, size, size) if batch else (size, size)
     matrix = torch.randn(*shape, dtype=torch.float64)
     matrix = matrix.matmul(matrix.mT)
-    matrix.div_(matrix.norm()).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
+    matrix.div_(torch.linalg.vector_norm(matrix)).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
     b_shape = (batch, size, 50) if batch else (size, 50)
     rhs = torch.randn(*b_shape, dtype=torch.float64)
     solves = linear_cg(matrix.matmul, rhs=rhs, max_iter=size)
@@ -72,7 +72,7 @@ def test_batch_cg_with_tridiag(batch):
     shape = (batch, size, size) if batch else (size, size)
     matrix = torch.randn(*shape, dtype=torch.float64)
     matrix = matrix.matmul(matrix.mT)
-    matrix.div_(matrix.norm()).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
+    matrix.div_(torch.linalg.vector_norm(matrix)).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
     b_shape = (batch, size, 10) if batch else (size, 10)
     rhs = torch.randn(*b_shape, dtype=torch.float64)
     solves, t_mats = linear_cg(
@@ -95,7 +95,7 @@ def test_batch_cg_init():
     size = 100
     matrix = torch.randn(batch, size, size, dtype=torch.float64)
     matrix = matrix.matmul(matrix.mT)
-    matrix.div_(matrix.norm()).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
+    matrix.div_(torch.linalg.vector_norm(matrix)).add_(torch.eye(size, dtype=torch.float64) * 1e-1)
     rhs = torch.randn(batch, size, 50, dtype=torch.float64)
     solves = linear_cg(matrix.matmul, rhs=rhs, max_iter=size, max_tridiag_iter=0)
     solves_init = linear_cg(matrix.matmul, rhs=rhs, max_iter=1, initial_guess=solves, max_tridiag_iter=0)

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/tests/test_minres.py

@@ -18,7 +18,7 @@ def _run_minres(rhs_shape, shifts=None, matrix_batch_shape=torch.Size([])):
     rhs = torch.randn(rhs_shape, dtype=torch.float64)
     matrix = torch.randn(*matrix_batch_shape, size, size, dtype=torch.float64)
     matrix = matrix @ matrix.mT
-    matrix = matrix / matrix.norm()
+    matrix = matrix / torch.linalg.vector_norm(matrix)
     matrix = matrix + torch.eye(size, dtype=torch.float64) * 1e-1
     # compute minres
     if shifts is not None:

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/tests/test_quickstart_guide.py

@@ -5,14 +5,9 @@ This module tests all code examples from the quickstart documentation to ensure
 It is integrated with pytest and runs as part of the CI pipeline.
 """
 
-import warnings
-
 import pytest
 import torch
 
-# Suppress warnings for cleaner test output
-warnings.filterwarnings("ignore")
-
 
 def test_sparse_mm_example():
     """Test the basic sparse matrix multiplication example from quickstart guide."""
@@ -76,7 +71,7 @@ def test_triangular_solve():
 
     # Verify solution (should be close to zero)
     residual = sparse_mm(L, x) - b
-    residual_norm = torch.norm(residual)
+    residual_norm = torch.linalg.vector_norm(residual)
     assert residual_norm < 1e-5, f"Residual too large: {residual_norm}"
 
 
@@ -97,7 +92,7 @@ def test_generic_solve():
 
     # Verify solution
     residual = A_sparse @ x_cg - b
-    residual_norm = torch.norm(residual)
+    residual_norm = torch.linalg.vector_norm(residual)
     assert residual_norm < 1e-4, f"Residual too large: {residual_norm}"
 
 

{torchsparsegradutils-0.2.4 → torchsparsegradutils-0.2.5}/torchsparsegradutils/tests/test_random.py

@@ -662,7 +662,7 @@ def test_make_spd_sparse_solve_system(device):
     try:
         x_dense = torch.linalg.solve(A_dense, b)
         residual = A_dense @ x_dense - b
-        residual_norm = torch.norm(residual).item()
+        residual_norm = torch.linalg.vector_norm(residual).item()
 
         # Check that residual is small
         assert residual_norm < 1e-10, f"Dense solve residual too large: {residual_norm}"