modularitypruning 2.0.0__tar.gz → 2.0.2__tar.gz

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modularitypruning
-Version: 2.0.0
+Version: 2.0.2
 Summary: Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference.
 Author-email: Ryan Gibson <ryan.alex.gibson@gmail.com>
 License-Expression: MIT
@@ -105,6 +105,6 @@ which is the stable 4-community split of the Karate Club network.
 
 ## More Information
 
-The [issues (which contains some potential future work)](https://github.com/ragibson/ModularityPruning/issues)
-and [figure generation runtimes README](figure_generation_runtimes.md) may also
-be of interest.
+The [issues](https://github.com/ragibson/ModularityPruning/issues) and
+[figure generation runtimes README](figure_generation_runtimes.md) may also be
+of interest.

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/README.md

@@ -74,6 +74,6 @@ which is the stable 4-community split of the Karate Club network.
 
 ## More Information
 
-The [issues (which contains some potential future work)](https://github.com/ragibson/ModularityPruning/issues)
-and [figure generation runtimes README](figure_generation_runtimes.md) may also
-be of interest.
+The [issues](https://github.com/ragibson/ModularityPruning/issues) and
+[figure generation runtimes README](figure_generation_runtimes.md) may also be
+of interest.

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/modularitypruning.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modularitypruning
-Version: 2.0.0
+Version: 2.0.2
 Summary: Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference.
 Author-email: Ryan Gibson <ryan.alex.gibson@gmail.com>
 License-Expression: MIT
@@ -105,6 +105,6 @@ which is the stable 4-community split of the Karate Club network.
 
 ## More Information
 
-The [issues (which contains some potential future work)](https://github.com/ragibson/ModularityPruning/issues)
-and [figure generation runtimes README](figure_generation_runtimes.md) may also
-be of interest.
+The [issues](https://github.com/ragibson/ModularityPruning/issues) and
+[figure generation runtimes README](figure_generation_runtimes.md) may also be
+of interest.

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/modularitypruning.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ tests/test_documentation_examples.py
 tests/test_monolayer_parameter_estimation.py
 tests/test_multiplex_parameter_estimation.py
 tests/test_parallel_leiden_performance.py
+tests/test_prune_stable_partitions.py
 tests/test_temporal_multilevel_parameter_estimation.py
 utilities/__init__.py
 utilities/champ_utilities.py

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modularitypruning"
-version = "2.0.0"
+version = "2.0.2"
 description = "Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -48,4 +48,14 @@ modularitypruning = "utilities"
 modularitypruning = ["py.typed"]
 
 [tool.autopep8]
-max_line_length = 120
+max_line_length = 120
+
+[tool.coverage.run]
+# a bit strange to include tests, but this is recommended by coverage.py
+source = ["modularitypruning", "tests"]
+concurrency = ["multiprocessing"]
+branch = true
+
+[tool.coverage.report]
+fail_under = 90
+show_missing = true

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/tests/test_monolayer_parameter_estimation.py

@@ -98,6 +98,8 @@ class TestMonolayerParameterEstimation(unittest.TestCase):
                 G_undirected.es['weight'] = weights
                 gamma_undirected_treatment = gamma_estimate(G_undirected, membership)
 
+                assert gamma_directed is not None
+                assert gamma_undirected_treatment is not None
                 self.assertGreater(abs(gamma_directed - gamma_undirected_treatment), 1e-2)
 
 

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/tests/test_multiplex_parameter_estimation.py

@@ -114,7 +114,7 @@ class TestMultiplexParameterEstimation(unittest.TestCase):
         one_way_edges = [(0, 1), (2, 3), (0, 2), (0, 3), (1, 2), (1, 3)]
         edge_list = one_way_edges + [(u + 4, v + 4) for (u, v) in one_way_edges]
         weights = [1.0, 2.0, 3.0, 3.0, 3.0, 3.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
-        membership = [0, 0, 1, 1, 0, 0, 1, 1]
+        membership = (0, 0, 1, 1, 0, 0, 1, 1)
         layer_membership = [0, 0, 0, 0, 1, 1, 1, 1]
         G_interlayer = ig.Graph([(0, 4), (4, 0), (1, 5), (5, 1), (2, 6), (6, 2), (3, 7), (7, 3)], directed=True)
 
@@ -128,6 +128,8 @@ class TestMultiplexParameterEstimation(unittest.TestCase):
             G_undirected.es['weight'] = weights
             gamma_undirected_treatment, _ = gamma_omega_estimate(G_undirected, G_interlayer, layer_membership,
                                                                  membership, model='multiplex')
+            assert gamma_directed is not None
+            assert gamma_undirected_treatment is not None
             self.assertGreater(abs(gamma_directed - gamma_undirected_treatment), 1e-2)
 
     def test_directed_consistency_multiplex_SBM_leiden(self):

modularitypruning-2.0.2/tests/test_prune_stable_partitions.py

@@ -0,0 +1,55 @@
+"""Simple tests of main pruning functions beyond the other testing scripts.
+
+These cover:
+- prune_to_stable_partitions
+- prune_to_multilayer_stable_partitions
+"""
+import unittest
+from random import seed
+
+from modularitypruning import prune_to_multilayer_stable_partitions, prune_to_stable_partitions
+from modularitypruning.leiden_utilities import multilayer_leiden, singlelayer_leiden
+
+from .shared_testing_functions import generate_connected_ER, generate_temporal_SBM
+
+
+class TestPruneToStablePartitions(unittest.TestCase):
+    def test_prune_leiden_partitions_and_membership_tuples_agree(self):
+        """Check that passing a list of leidenalg partitions operates the same as a list of membership tuples."""
+        G = generate_connected_ER(n=50, m=200, directed=False)
+        partitions = [singlelayer_leiden(G, gamma, return_partition=True)
+                      for gamma in [0.25, 0.5, 0.75, 1.0, 1.25, 1.5]]
+        membership_tuples = [tuple(part.membership) for part in partitions]
+
+        stable_from_tuples = prune_to_stable_partitions(G, membership_tuples, 0, 2)
+        stable_from_partitions = prune_to_stable_partitions(G, partitions, 0, 2)
+
+        self.assertEqual(stable_from_partitions, stable_from_tuples)
+        self.assertTrue(stable_from_tuples)  # non-empty
+
+
+class TestPruneToMultilayerStablePartitions(unittest.TestCase):
+    def test_prune_leiden_partitions_and_membership_tuples_agree(self):
+        """Check that passing a list of leidenalg partitions operates the same as a list of membership tuples."""
+        G_intralayer, G_interlayer, layer_vec = generate_temporal_SBM(
+            copying_probability=0.75, p_in=0.6, p_out=0.05,
+            first_layer_membership=[0] * 10 + [1] * 10, num_layers=2)
+
+        partition_runs = [multilayer_leiden(G_intralayer, G_interlayer, layer_vec, gamma, omega, return_partition=True)
+                          for gamma in [0.5, 1.0, 1.5, 2.0] for omega in [0.5, 1.0, 1.5, 2.0]]
+
+        partitions = [run[0] for run in partition_runs]
+        membership_tuples = [tuple(part.membership) for part in partitions]
+
+        stable_from_tuples = prune_to_multilayer_stable_partitions(
+            G_intralayer, G_interlayer, layer_vec, 'temporal', membership_tuples, 0, 2, 0, 2)
+        stable_from_partitions = prune_to_multilayer_stable_partitions(
+            G_intralayer, G_interlayer, layer_vec, 'temporal', partitions, 0, 2, 0, 2)
+
+        self.assertEqual(stable_from_partitions, stable_from_tuples)
+        self.assertTrue(stable_from_tuples)  # non-empty
+
+
+if __name__ == "__main__":
+    seed(0)
+    unittest.main()

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/tests/test_temporal_multilevel_parameter_estimation.py

@@ -159,7 +159,7 @@ class TestTemporalAndMultilevelParameterEstimation(unittest.TestCase):
         one_way_edges = [(0, 1), (2, 3), (0, 2), (0, 3), (1, 2), (1, 3)]
         edge_list = one_way_edges + [(u + 4, v + 4) for (u, v) in one_way_edges]
         weights = [1.0, 2.0, 3.0, 3.0, 3.0, 3.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
-        membership = [0, 0, 1, 1, 0, 0, 1, 1]
+        membership = (0, 0, 1, 1, 0, 0, 1, 1)
         layer_membership = [0, 0, 0, 0, 1, 1, 1, 1]
         G_interlayer = ig.Graph([(0, 4), (1, 5), (2, 6), (3, 7)], directed=True)
 
@@ -174,6 +174,8 @@ class TestTemporalAndMultilevelParameterEstimation(unittest.TestCase):
                 G_undirected.es['weight'] = weights
                 gamma_undirected_treatment, _ = gamma_omega_estimate(G_undirected, G_interlayer, layer_membership,
                                                                      membership, model=model)
+                assert gamma_directed is not None
+                assert gamma_undirected_treatment is not None
                 self.assertGreater(abs(gamma_directed - gamma_undirected_treatment), 1e-2)
 
     def test_directed_consistency_temporal_SBM_leiden(self):

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/utilities/champ_utilities.py

@@ -35,68 +35,69 @@ def get_interior_point(
     # We suppress these two warnings to avoid cluttering output, some of these warnings are expected as the result is
     # converged to and we've checked the consistency of results in our own tests. Moreover, we explicitly check the
     # interior point's validity prior to returning.
-    warnings.filterwarnings("ignore", category=LinAlgWarning)
-    warnings.filterwarnings("ignore", category=OptimizeWarning)
-
-    normals, offsets = np.split(halfspaces, [-1], axis=1)
-
-    # in our singlelayer case, the last four halfspaces are boundary halfspaces (a square)
-    # for multilayer, the last six are boundaries (a cube)
-    if normals.shape[1] == 2:
-        interior_hs, boundaries = np.split(halfspaces, [-4], axis=0)
-    elif normals.shape[1] == 3:
-        interior_hs, boundaries = np.split(halfspaces, [-6], axis=0)
-    else:
-        raise ValueError(f"get_interior_point received unhandled dimension {normals.shape[1]}!")
-
-    num_retries: int = 0
-
-    while True:  # retry until success
-        # randomly sample some of the halfspaces
-        sample_len: int = min(initial_num_sampled, len(interior_hs))  # len(interior_hs)
-        sampled_hs: FloatArray = np.vstack((
-            interior_hs[choice(interior_hs.shape[0], sample_len, replace=False)], boundaries))
-
-        # compute the Chebyshev center of the sampled halfspaces' intersection
-        norm_vector: FloatArray = np.reshape(
-            np.linalg.norm(sampled_hs[:, :-1], axis=1), (sampled_hs.shape[0], 1))
-        c: FloatArray = np.zeros((sampled_hs.shape[1],))
-        c[-1] = -1
-        A: FloatArray = np.hstack((sampled_hs[:, :-1], norm_vector))
-        b: FloatArray = -sampled_hs[:, -1:]
-
-        res = linprog(c, A_ub=A, b_ub=b, bounds=(-np.inf, np.inf), method='highs-ipm')
-
-        # check solution if optimization succeeded, even with difficulties
-        #     res.status codes
-        #     0 : Optimization terminated successfully.
-        #     1 : Iteration limit reached.
-        #     2 : Problem appears to be infeasible.
-        #     3 : Problem appears to be unbounded.
-        #     4 : Numerical difficulties encountered.
-        if res.success or res.status in {0, 1, 4}:
-            if res.x is None:
-                # satisfying mypy, this should never occur
-                raise ValueError(f"Scipy's linprog claimed success but returned no solution! {res}")
-            intpt: FloatArray = res.x[:-1]  # res.x contains [interior_point, distance to enclosing polyhedron]
-
-            # ensure that the computed point is actually interior to all halfspaces
-            if (np.dot(normals, intpt) + np.transpose(offsets) < 0).all():
-                break
-        elif res.status in {2, 3}:
-            # if we ever fail, the linear program seems impossible
-            raise ValueError("get_interior_point problem is impossible or degenerate!")
-
-        if num_retries > full_retry_limit:
-            raise ValueError("get_interior_point is unable to find a well-conditioned solution, "
-                             "but the problem does not appear impossible or degenerate?")
-
-        if initial_num_sampled >= len(interior_hs):
-            num_retries += 1
+    with warnings.catch_warnings():  # revert our filters once we're done
+        warnings.filterwarnings("ignore", category=LinAlgWarning)
+        warnings.filterwarnings("ignore", category=OptimizeWarning)
+
+        normals, offsets = np.split(halfspaces, [-1], axis=1)
+
+        # in our singlelayer case, the last four halfspaces are boundary halfspaces (a square)
+        # for multilayer, the last six are boundaries (a cube)
+        if normals.shape[1] == 2:
+            interior_hs, boundaries = np.split(halfspaces, [-4], axis=0)
+        elif normals.shape[1] == 3:
+            interior_hs, boundaries = np.split(halfspaces, [-6], axis=0)
         else:
-            initial_num_sampled *= 2  # try again and sample more halfspaces this time
-
-    return intpt
+            raise ValueError(f"get_interior_point received unhandled dimension {normals.shape[1]}!")
+
+        num_retries: int = 0
+
+        while True:  # retry until success
+            # randomly sample some of the halfspaces
+            sample_len: int = min(initial_num_sampled, len(interior_hs))  # len(interior_hs)
+            sampled_hs: FloatArray = np.vstack((
+                interior_hs[choice(interior_hs.shape[0], sample_len, replace=False)], boundaries))
+
+            # compute the Chebyshev center of the sampled halfspaces' intersection
+            norm_vector: FloatArray = np.reshape(
+                np.linalg.norm(sampled_hs[:, :-1], axis=1), (sampled_hs.shape[0], 1))
+            c: FloatArray = np.zeros((sampled_hs.shape[1],))
+            c[-1] = -1
+            A: FloatArray = np.hstack((sampled_hs[:, :-1], norm_vector))
+            b: FloatArray = -sampled_hs[:, -1:]
+
+            res = linprog(c, A_ub=A, b_ub=b, bounds=(-np.inf, np.inf), method='highs-ipm')
+
+            # check solution if optimization succeeded, even with difficulties
+            #     res.status codes
+            #     0 : Optimization terminated successfully.
+            #     1 : Iteration limit reached.
+            #     2 : Problem appears to be infeasible.
+            #     3 : Problem appears to be unbounded.
+            #     4 : Numerical difficulties encountered.
+            if res.success or res.status in {0, 1, 4}:
+                if res.x is None:
+                    # satisfying mypy, this should never occur
+                    raise ValueError(f"Scipy's linprog claimed success but returned no solution! {res}")
+                intpt: FloatArray = res.x[:-1]  # res.x contains [interior_point, distance to enclosing polyhedron]
+
+                # ensure that the computed point is actually interior to all halfspaces
+                if (np.dot(normals, intpt) + np.transpose(offsets) < 0).all():
+                    break
+            elif res.status in {2, 3}:
+                # if we ever fail, the linear program seems impossible
+                raise ValueError("get_interior_point problem is impossible or degenerate!")
+
+            if num_retries > full_retry_limit:
+                raise ValueError("get_interior_point is unable to find a well-conditioned solution, "
+                                 "but the problem does not appear impossible or degenerate?")
+
+            if initial_num_sampled >= len(interior_hs):
+                num_retries += 1
+            else:
+                initial_num_sampled *= 2  # try again and sample more halfspaces this time
+
+        return intpt
 
 
 def CHAMP_2D(

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/utilities/parameter_estimation_utilities.py

@@ -13,7 +13,7 @@ from .partition_utilities import num_communities
 from .types import (Domain, DomainWithEstimates, FloatArray, GammaEstimate,
                     GammaEstimateValue, GammaOmegaEstimate, GammaRange, GammaUpdateFunc, LayerVector,
                     LeidenPartition, Membership, MultilayerSBMParameters, OmegaUpdateFunc,
-                    PersistenceFunc, SinglelayerSBMParameters)
+                    PersistenceFunc, PrunablePartitions, SinglelayerSBMParameters)
 
 
 def estimate_singlelayer_SBM_parameters(
@@ -353,7 +353,7 @@ def omega_function_from_model(
     :type model: str
     :param omega_max: maximum allowed value for omega
     :type omega_max: float
-    :param T: number of layers in input graph (automatically computed if None)
+    :param T: number of layers in input graph
     :type T: int
     :return: an "update_omega" function
     :rtype: function
@@ -575,7 +575,6 @@ def gamma_omega_estimates_to_stable_partitions(
 
     for polyverts, membership, gamma_est, omega_est in domains_with_estimates:
         if gamma_est is None or omega_est is None:
-            print(gamma_est, omega_est)
             continue
 
         centroid_x: float = np.mean([x[0] for x in polyverts])
@@ -604,7 +603,7 @@ def gamma_omega_estimates_to_stable_partitions(
 
 
 def prune_to_stable_partitions(
-    G: ig.Graph, parts: set[Membership],
+    G: ig.Graph, parts: PrunablePartitions,
     gamma_start: float, gamma_end: float,
     restrict_num_communities: int | None = None,
     single_threaded: bool = False
@@ -620,7 +619,7 @@ def prune_to_stable_partitions(
     :param G: graph of interest
     :type G: igraph.Graph
     :param parts: partitions to prune
-    :type parts: set[tuple[int, ...]]
+    :type parts: list or set of membership tuples or leidenalg.RBConfigurationVertexPartitions
     :param gamma_start: starting gamma value for CHAMP
     :type gamma_start: float
     :param gamma_end: ending gamma value for CHAMP
@@ -633,7 +632,7 @@ def prune_to_stable_partitions(
     :rtype: list[tuple[int, ...]]
     """
 
-    if not G.is_connected():
+    if not G.is_connected(mode='weak'):
         warnings.warn("The pruning pipeline has not been thoroughly tested on disconnected graphs. If you run into "
                       "problems, consider using the largest connected component of your graph.")
 
@@ -643,12 +642,15 @@ def prune_to_stable_partitions(
         if sum(G.es['weight']) <= 0:
             raise ValueError("Total edge weight must be positive.")
 
-    if isinstance(parts, leidenalg.RBConfigurationVertexPartition):
-        # convert to (canonically represented) membership vectors if necessary
-        parts = {sorted_tuple(part.membership) for part in parts}
-    else:
-        # assume parts contains membership vectors
-        parts = {sorted_tuple(part) for part in parts}
+    canonical_parts: set[Membership] = set()
+    for part in parts:
+        if isinstance(part, leidenalg.RBConfigurationVertexPartition):
+            # convert to (canonically represented) membership vectors if necessary
+            canonical_parts.add(sorted_tuple(tuple(part.membership)))
+        else:
+            # assume parts contains membership vectors
+            canonical_parts.add(sorted_tuple(part))
+    parts = canonical_parts
 
     if restrict_num_communities is not None:
         parts = {part for part in parts if num_communities(part) == restrict_num_communities}
@@ -668,7 +670,7 @@ def prune_to_stable_partitions(
 def prune_to_multilayer_stable_partitions(
     G_intralayer: ig.Graph, G_interlayer: ig.Graph,
     layer_vec: LayerVector, model: str,
-    parts: set[Membership], gamma_start: float, gamma_end: float,
+    parts: PrunablePartitions, gamma_start: float, gamma_end: float,
     omega_start: float, omega_end: float,
     restrict_num_communities: int | None = None, single_threaded: bool = False
 ) -> list[Membership]:
@@ -713,7 +715,7 @@ def prune_to_multilayer_stable_partitions(
     :param model: network layer topology (temporal, multilevel, multiplex)
     :type model: str
     :param parts: partitions to prune
-    :type parts: set[tuple[int, ...]]
+    :type parts: list or set of membership tuples or leidenalg.RBConfigurationVertexPartitions
     :param gamma_start: starting gamma value for CHAMP
     :type gamma_start: float
     :param gamma_end: ending gamma value for CHAMP
@@ -736,7 +738,7 @@ def prune_to_multilayer_stable_partitions(
     # check graph is connected (cannot just check intra/interlayer graphs since they will both be disconnected)
     G_combined: ig.Graph = ig.Graph(edges=[(e.source, e.target) for e in G_intralayer.es] +
                                     [(e.source, e.target) for e in G_interlayer.es])
-    if not G_combined.is_connected() or G_combined.vcount() != G_interlayer.vcount():
+    if not G_combined.is_connected(mode='weak') or G_combined.vcount() != G_interlayer.vcount():
         warnings.warn("The pruning pipeline has not been thoroughly tested on disconnected graphs. If you run into "
                       "problems, consider using the largest connected component of your graph.")
 
@@ -751,12 +753,15 @@ def prune_to_multilayer_stable_partitions(
         warnings.warn("Parameter estimation treats interlayer edges as unweighted and will proceed as though all "
                       "interlayer weights are 1.0, but CHAMP will still use the actual interlayer weights!")
 
-    if isinstance(parts, leidenalg.RBConfigurationVertexPartition):
-        # convert to (canonically represented) membership vectors if necessary
-        parts = {sorted_tuple(part.membership) for part in parts}
-    else:
-        # assume parts contains membership vectors
-        parts = {sorted_tuple(part) for part in parts}
+    canonical_parts: set[Membership] = set()
+    for part in parts:
+        if isinstance(part, leidenalg.RBConfigurationVertexPartition):
+            # convert to (canonically represented) membership vectors if necessary
+            canonical_parts.add(sorted_tuple(tuple(part.membership)))
+        else:
+            # assume parts contains membership vectors
+            canonical_parts.add(sorted_tuple(part))
+    parts = canonical_parts
 
     if restrict_num_communities is not None:
         parts = {part for part in parts if num_communities(part) == restrict_num_communities}

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/utilities/plotting.py

@@ -89,7 +89,7 @@ def plot_2d_domains(
 ) -> None:
     """Plot partition dominance ranges in the (gamma, omega) plane, using the domains from CHAMP_3D.
 
-    Limits output to xlim and ylim dimensions. Note that the plotting here has x=gamma and y=omega.
+    Limits output to xlim and ylim dimensions. Note that the plotting here has x=omega and y=gamma by default.
 
     :param domains: CHAMP domains as returned from :meth:`~modularitypruning.champ_utilities.CHAMP_3D`.
     :param xlim: plotting x limits

{modularitypruning-2.0.0 → modularitypruning-2.0.2}/utilities/types.py

@@ -16,6 +16,7 @@ IntSequence = Sequence[int] | IntArray
 FloatSequence = Sequence[float] | FloatArray
 
 # community membership vector and layer membership vector
+# note: some parts of the code do actually support list[int] for membership, but this is simpler and more consistent
 Membership = tuple[int, ...]
 LayerVector = list[int]
 LayerTuple = tuple[int, ...]  # needed for hashing
@@ -29,6 +30,9 @@ MultilayerLeidenParts: TypeAlias = tuple[list[LeidenPartition], leidenalg.CPMVer
 SingleLayerLeidenResult: TypeAlias = LeidenPartition | Membership
 MultilayerLeidenResult: TypeAlias = list[LeidenPartition] | Membership
 
+# collections of partitions for pruning (membership vectors or leiden partitions)
+PrunablePartitions = Sequence[LeidenPartition | Membership] | set[LeidenPartition | Membership]
+
 # CHAMP 2D domains and parameter estimates
 GammaEstimateValue = np.float64 | None
 GammaEstimate = tuple[np.float64, np.float64, Membership, GammaEstimateValue]