modssc 1.2.1__tar.gz → 1.2.2__tar.gz

{modssc-1.2.1 → modssc-1.2.2}/.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - uses: actions/setup-python@v6
         with:
@@ -41,7 +41,7 @@ jobs:
       matrix:
         python-version: ["3.11", "3.12"]
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - name: Free up disk space
         run: |
@@ -92,7 +92,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - uses: actions/setup-python@v6
         with:

{modssc-1.2.1 → modssc-1.2.2}/.github/workflows/docs.yml

@@ -36,7 +36,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - name: Setup Pages
         uses: actions/configure-pages@v6

{modssc-1.2.1 → modssc-1.2.2}/.github/workflows/release.yml

@@ -16,7 +16,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - uses: actions/setup-python@v6
         with:
@@ -63,7 +63,7 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - name: Download dist artifacts
         uses: actions/download-artifact@v8

{modssc-1.2.1 → modssc-1.2.2}/CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 
 The format is based on "Keep a Changelog", and this project adheres to Semantic Versioning.
 
+## 1.2.2
+### Fixed
+- Stabilized Dynamic Label Propagation by renormalizing dynamic transition matrices after each update and failing explicitly on invalid transition weights instead of returning non-finite scores.
+- Replaced torch sparse tensor coalescing in DGI and GNN graph helpers with deterministic duplicate-edge aggregation to avoid PyTorch sparse invariant warnings without disabling checks.
+
 ## 1.2.1
 ### Changed
 - Added benchmark seed-section control for reproducible ISO-style sweeps.

{modssc-1.2.1 → modssc-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modssc
-Version: 1.2.1
+Version: 1.2.2
 Summary: ModSSC: a modular framework for semi-supervised classification on heterogeneous data
 Project-URL: Homepage, https://github.com/ModSSC/ModSSC
 Project-URL: Repository, https://github.com/ModSSC/ModSSC

{modssc-1.2.1 → modssc-1.2.2}/docs/index.md

@@ -44,7 +44,7 @@ ModSSC is a modular framework for semi-supervised classification across heteroge
 - [Troubleshooting](how-to/troubleshooting.md)
 
 ## Version
-Current version is `1.2.0`, sourced from [`src/modssc/__about__.py`](https://github.com/ModSSC/ModSSC/blob/main/src/modssc/__about__.py) and referenced by the Hatch version config in [`pyproject.toml`](https://github.com/ModSSC/ModSSC/blob/main/pyproject.toml). <sup class="cite"><a href="#source-18">[18]</a><a href="#source-2">[2]</a></sup>
+Current version is `1.2.2`, sourced from [`src/modssc/__about__.py`](https://github.com/ModSSC/ModSSC/blob/main/src/modssc/__about__.py) and referenced by the Hatch version config in [`pyproject.toml`](https://github.com/ModSSC/ModSSC/blob/main/pyproject.toml). <sup class="cite"><a href="#source-18">[18]</a><a href="#source-2">[2]</a></sup>
 
 
 ## Project status and support

{modssc-1.2.1 → modssc-1.2.2}/src/modssc/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present ModSSC contributors
 #
 # SPDX-License-Identifier: MIT
-__version__ = "1.2.1"
+__version__ = "1.2.2"

{modssc-1.2.1 → modssc-1.2.2}/src/modssc/preprocess/steps/graph/dgi.py

@@ -65,9 +65,11 @@ def _train_dgi(
     def _coalesce_edges(edge_index_t, edge_weight_t, *, n_nodes: int):
         src, dst = edge_index_t[0], edge_index_t[1]
         idx = torch.stack([dst, src], dim=0)
-        adj = torch.sparse_coo_tensor(idx, edge_weight_t, size=(n_nodes, n_nodes)).coalesce()
-        idx2 = adj.indices()
-        w2 = adj.values()
+        idx2, inverse = torch.unique(idx, dim=1, sorted=True, return_inverse=True)
+        w2 = torch.zeros(
+            (int(idx2.shape[1]),), device=edge_weight_t.device, dtype=edge_weight_t.dtype
+        )
+        w2.scatter_add_(0, inverse, edge_weight_t)
         dst2, src2 = idx2[0], idx2[1]
         return torch.stack([src2, dst2], dim=0), w2
 

{modssc-1.2.1 → modssc-1.2.2}/src/modssc/transductive/methods/classic/dynamic_label_propagation.py

@@ -53,6 +53,19 @@ def _knn_matrix_numpy(P0: np.ndarray, k: int) -> np.ndarray:
     return P
 
 
+def _normalize_transition_numpy(P: np.ndarray, eps: float = 1e-12) -> np.ndarray:
+    row_sum = P.sum(axis=1, keepdims=True)
+    invalid = (
+        (not bool(np.isfinite(P).all()))
+        or bool((P < 0.0).any())
+        or (not bool(np.isfinite(row_sum).all()))
+        or bool((row_sum <= eps).any())
+    )
+    if invalid:
+        raise ValueError("DynamicLabelPropagation produced invalid transition weights.")
+    return P / row_sum
+
+
 def dynamic_label_propagation_numpy(
     *,
     n_nodes: int,
@@ -68,6 +81,8 @@ def dynamic_label_propagation_numpy(
         raise ValueError("k_neighbors must be positive")
     if not (float(spec.alpha) >= 0.0):
         raise ValueError("alpha must be non-negative")
+    if not (float(spec.lambda_value) >= 0.0):
+        raise ValueError("lambda_value must be non-negative")
 
     edge_index, w = _validate_graph_inputs(
         n_nodes=n_nodes, edge_index=edge_index, edge_weight=edge_weight
@@ -90,8 +105,8 @@ def dynamic_label_propagation_numpy(
     if np.any(deg <= 0):
         raise ValueError("DynamicLabelPropagation requires a graph without isolated nodes.")
 
-    P0 = W / deg[:, None]
-    P = _knn_matrix_numpy(P0, int(spec.k_neighbors))
+    P0 = _normalize_transition_numpy(W / deg[:, None])
+    P = _normalize_transition_numpy(_knn_matrix_numpy(P0, int(spec.k_neighbors)))
 
     P_t = P0.copy()
     Y_t = Y0.copy()
@@ -105,6 +120,7 @@ def dynamic_label_propagation_numpy(
         P_t = P @ (P_t + float(spec.alpha) * (Y_t @ Y_t.T)) @ P.T
         if float(spec.lambda_value) != 0.0:
             P_t = P_t + float(spec.lambda_value) * identity
+        P_t = _normalize_transition_numpy(P_t)
 
         residual = float(np.max(np.abs(Y_next - Y_t)))
         Y_t = Y_next
@@ -130,6 +146,19 @@ def _knn_matrix_torch(P0: torch.Tensor, k: int) -> torch.Tensor:
     return P
 
 
+def _normalize_transition_torch(P: torch.Tensor, eps: float = 1e-12) -> torch.Tensor:
+    row_sum = P.sum(dim=1, keepdim=True)
+    invalid = (
+        (not bool(torch.isfinite(P).all().item()))
+        or bool((P < 0.0).any().item())
+        or (not bool(torch.isfinite(row_sum).all().item()))
+        or bool((row_sum <= float(eps)).any().item())
+    )
+    if invalid:
+        raise ValueError("DynamicLabelPropagation produced invalid transition weights.")
+    return P / row_sum
+
+
 def dynamic_label_propagation_torch(
     *,
     n_nodes: int,
@@ -147,6 +176,8 @@ def dynamic_label_propagation_torch(
         raise ValueError("k_neighbors must be positive")
     if not (float(spec.alpha) >= 0.0):
         raise ValueError("alpha must be non-negative")
+    if not (float(spec.lambda_value) >= 0.0):
+        raise ValueError("lambda_value must be non-negative")
 
     if edge_index.ndim != 2 or int(edge_index.shape[0]) != 2:
         raise ValueError("edge_index must have shape (2, E)")
@@ -180,8 +211,8 @@ def dynamic_label_propagation_torch(
     if bool((deg <= 0).any().item()):
         raise ValueError("DynamicLabelPropagation requires a graph without isolated nodes.")
 
-    P0 = W / deg.view(-1, 1)
-    P = _knn_matrix_torch(P0, int(spec.k_neighbors))
+    P0 = _normalize_transition_torch(W / deg.view(-1, 1))
+    P = _normalize_transition_torch(_knn_matrix_torch(P0, int(spec.k_neighbors)))
 
     P_t = P0.clone()
     Y_t = Y0.clone()
@@ -195,6 +226,7 @@ def dynamic_label_propagation_torch(
         P_t = P @ (P_t + float(spec.alpha) * (Y_t @ Y_t.T)) @ P.T
         if float(spec.lambda_value) != 0.0:
             P_t = P_t + float(spec.lambda_value) * identity
+        P_t = _normalize_transition_torch(P_t)
 
         residual = float(torch.max(torch.abs(Y_next - Y_t)).item())
         Y_t = Y_next

{modssc-1.2.1 → modssc-1.2.2}/src/modssc/transductive/methods/gnn/common.py

@@ -88,14 +88,18 @@ def coalesce_edges(edge_index: Any, edge_weight: Any, *, n_nodes: int) -> tuple[
     """Coalesce duplicate edges by summing weights.
 
     The internal adjacency convention in ModSSC is PyG-like: edge_index is
-    (src, dst) and corresponds to adjacency A[dst, src]. We therefore build a
-    sparse tensor with indices (dst, src).
+    (src, dst) and corresponds to adjacency A[dst, src]. Duplicate edges are
+    aggregated deterministically by their (dst, src) key.
     """
+    if edge_index.numel() and (
+        bool((edge_index < 0).any().item()) or bool((edge_index >= int(n_nodes)).any().item())
+    ):
+        raise ValueError("edge_index contains node id outside [0, n_nodes)")
     src, dst = edge_index[0], edge_index[1]
     idx = torch.stack([dst, src], dim=0)
-    A = torch.sparse_coo_tensor(idx, edge_weight, size=(n_nodes, n_nodes)).coalesce()
-    idx2 = A.indices()
-    w2 = A.values()
+    idx2, inverse = torch.unique(idx, dim=1, sorted=True, return_inverse=True)
+    w2 = torch.zeros((int(idx2.shape[1]),), device=edge_weight.device, dtype=edge_weight.dtype)
+    w2.scatter_add_(0, inverse, edge_weight)
     dst2, src2 = idx2[0], idx2[1]
     return torch.stack([src2, dst2], dim=0), w2
 

{modssc-1.2.1 → modssc-1.2.2}/tests/transductive/methods/classic/test___init__.py

@@ -25,6 +25,9 @@ from modssc.transductive.methods.classic.dynamic_label_propagation import (
 from modssc.transductive.methods.classic.dynamic_label_propagation import (
     _knn_matrix_numpy as _dlp_knn_numpy,
 )
+from modssc.transductive.methods.classic.dynamic_label_propagation import (
+    _normalize_transition_numpy as _dlp_normalize_transition_numpy,
+)
 from modssc.transductive.methods.classic.label_propagation import (
     LabelPropagationMethod,
     LabelPropagationSpec,
@@ -62,6 +65,9 @@ if torch is not None:
     from modssc.transductive.methods.classic.dynamic_label_propagation import (
         _knn_matrix_torch as _dlp_knn_torch,
     )
+    from modssc.transductive.methods.classic.dynamic_label_propagation import (
+        _normalize_transition_torch as _dlp_normalize_transition_torch,
+    )
     from modssc.transductive.methods.classic.dynamic_label_propagation import (
         dynamic_label_propagation_torch,
     )
@@ -1272,6 +1278,13 @@ def test_dynamic_label_propagation_knn_matrix_numpy_paths():
         _dlp_knn_numpy(np.zeros((3, 3), dtype=np.float32), 1)
 
 
+def test_dynamic_label_propagation_normalize_transition_numpy_paths():
+    P = np.array([[2.0, 0.0], [1.0, 1.0]], dtype=np.float32)
+    assert np.allclose(_dlp_normalize_transition_numpy(P), [[1.0, 0.0], [0.5, 0.5]])
+    with pytest.raises(ValueError, match="invalid transition weights"):
+        _dlp_normalize_transition_numpy(np.array([[np.nan, 1.0]], dtype=np.float32))
+
+
 @pytest.mark.parametrize(
     ("spec", "y", "labeled_mask", "edge_index", "edge_weight", "match"),
     [
@@ -1289,6 +1302,13 @@ def test_dynamic_label_propagation_knn_matrix_numpy_paths():
             *_simple_graph(),
             "alpha must be non-negative",
         ),
+        (
+            DynamicLabelPropagationSpec(lambda_value=-0.1),
+            np.array([0, 1, 0], dtype=np.int64),
+            np.array([True, False, True]),
+            *_simple_graph(),
+            "lambda_value must be non-negative",
+        ),
         (
             DynamicLabelPropagationSpec(),
             np.array([0, 1], dtype=np.int64),
@@ -1346,6 +1366,7 @@ def test_dynamic_label_propagation_numpy_lambda_zero():
         spec=DynamicLabelPropagationSpec(k_neighbors=1, lambda_value=0.0, max_iter=1),
     )
     assert res.F.shape == (3, 2)
+    assert np.isfinite(res.F).all()
 
 
 def test_dynamic_label_propagation_numpy_default_spec():
@@ -1360,6 +1381,7 @@ def test_dynamic_label_propagation_numpy_default_spec():
         labeled_mask=labeled_mask,
     )
     assert res.F.shape == (3, 2)
+    assert np.isfinite(res.F).all()
 
 
 def test_dynamic_label_propagation_dispatch_invalid_backend():
@@ -1393,6 +1415,7 @@ def test_dynamic_label_propagation_torch_paths():
         device="cpu",
     )
     assert res.F.shape == (3, 2)
+    assert np.isfinite(res.F).all()
 
 
 @pytest.mark.skipif(torch is None, reason="torch not installed")
@@ -1419,6 +1442,15 @@ def test_dynamic_label_propagation_knn_matrix_torch_paths():
         _dlp_knn_torch(torch.zeros((3, 3), dtype=torch.float32), 1)
 
 
+@pytest.mark.skipif(torch is None, reason="torch not installed")
+def test_dynamic_label_propagation_normalize_transition_torch_paths():
+    P = torch.tensor([[2.0, 0.0], [1.0, 1.0]], dtype=torch.float32)
+    expected = torch.tensor([[1.0, 0.0], [0.5, 0.5]], dtype=torch.float32)
+    assert torch.allclose(_dlp_normalize_transition_torch(P), expected)
+    with pytest.raises(ValueError, match="invalid transition weights"):
+        _dlp_normalize_transition_torch(torch.tensor([[float("nan"), 1.0]]))
+
+
 @pytest.mark.skipif(torch is None, reason="torch not installed")
 @pytest.mark.parametrize(
     ("spec", "edge_index", "edge_weight", "y", "labeled_mask", "match"),
@@ -1439,6 +1471,14 @@ def test_dynamic_label_propagation_knn_matrix_torch_paths():
             torch.tensor([True, False, True], dtype=torch.bool),
             "alpha must be non-negative",
         ),
+        (
+            DynamicLabelPropagationSpec(lambda_value=-0.1),
+            torch.tensor([[0, 1], [1, 2]], dtype=torch.long),
+            torch.ones(2, dtype=torch.float32),
+            torch.tensor([0, 1, 0], dtype=torch.long),
+            torch.tensor([True, False, True], dtype=torch.bool),
+            "lambda_value must be non-negative",
+        ),
         (
             DynamicLabelPropagationSpec(),
             torch.tensor([[0, 1], [1, 2]], dtype=torch.long),

{modssc-1.2.1 → modssc-1.2.2}/tests/transductive/methods/gnn/_methods.py

@@ -672,6 +672,19 @@ def test_common_utils():
     assert ei_out[1, 0] == 1
     assert ew_out[0] == 3.0
 
+    ei_empty = torch.empty((2, 0), dtype=torch.long)
+    ew_empty = torch.empty((0,), dtype=torch.float)
+    ei_empty_out, ew_empty_out = coalesce_edges(ei_empty, ew_empty, n_nodes=2)
+    assert ei_empty_out.shape == (2, 0)
+    assert ew_empty_out.shape == (0,)
+
+    with pytest.raises(ValueError, match="outside"):
+        coalesce_edges(
+            torch.tensor([[0, 2], [1, 0]], dtype=torch.long),
+            torch.ones(2, dtype=torch.float),
+            n_nodes=2,
+        )
+
     with pytest.raises(ValueError, match="X must be 2D"):
         _ensure_2d(np.zeros((2, 2, 2)))