modularitypruning 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

modularitypruning/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/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/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/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]

{modularitypruning-2.0.0.dist-info → modularitypruning-2.0.2.dist-info}/METADATA

@@ -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.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+modularitypruning/__init__.py,sha256=eYablsXHzunDPuF96E3PFk3Zkmq_4jlG2p1wtC_Rxdk,397
+modularitypruning/champ_utilities.py,sha256=KHHAOJjotD1EmCRESchOgdPiMZtDaohFJrZSXUzBHs0,19451
+modularitypruning/leiden_utilities.py,sha256=ZTEklT0hmqDqAmZW85kkVq-zqjnFABbwFUt0IFzELB4,13376
+modularitypruning/louvain_utilities.py,sha256=gRRXTLbxYP6z2FMN5F1BjGv2vsC0Cg5qezLUYlAJMRs,1184
+modularitypruning/parameter_estimation.py,sha256=nMq2qzDIlPDKzAos3_eJzNKayrjUDC28s4MrhnoFgJw,11541
+modularitypruning/parameter_estimation_utilities.py,sha256=DWWZHrwMHHzC5q6wlacAoYAw4fkwmDTsNu-4ZGyT0HM,35961
+modularitypruning/partition_utilities.py,sha256=_QAFKPUQlt-v_D7fydu-CbPvFZM9lw3qpxfX09Gv7Zw,1914
+modularitypruning/plotting.py,sha256=2pwyQQweObJ86dAVySwpLzpHXn746k7nBLJLQ-2Dghs,12260
+modularitypruning/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modularitypruning/types.py,sha256=Y0PdwtI_0lsolXo38brelOzH7Xdr0bPBqJxr6NXoABc,2740
+modularitypruning-2.0.2.dist-info/licenses/LICENSE,sha256=eWz3HIQQxg7p1iSpUOUDKdDhGcuMPuVDDlcXf9F12D8,1068
+modularitypruning-2.0.2.dist-info/METADATA,sha256=SHmgeE2J6CEYSDDxEoaffURESRp7dTsZzkDKSyFLB7o,3928
+modularitypruning-2.0.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+modularitypruning-2.0.2.dist-info/top_level.txt,sha256=ZPOx3a-ek0Ge0ZMq-uvbySSaAL9MZ-t23-JkuHZXo9E,18
+modularitypruning-2.0.2.dist-info/RECORD,,

{modularitypruning-2.0.0.dist-info → modularitypruning-2.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

modularitypruning-2.0.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-modularitypruning/__init__.py,sha256=eYablsXHzunDPuF96E3PFk3Zkmq_4jlG2p1wtC_Rxdk,397
-modularitypruning/champ_utilities.py,sha256=ak3qklwqS_rLX3J4qK2fA05hjBuBTMmUWR3-DDaurDw,19173
-modularitypruning/leiden_utilities.py,sha256=ZTEklT0hmqDqAmZW85kkVq-zqjnFABbwFUt0IFzELB4,13376
-modularitypruning/louvain_utilities.py,sha256=gRRXTLbxYP6z2FMN5F1BjGv2vsC0Cg5qezLUYlAJMRs,1184
-modularitypruning/parameter_estimation.py,sha256=nMq2qzDIlPDKzAos3_eJzNKayrjUDC28s4MrhnoFgJw,11541
-modularitypruning/parameter_estimation_utilities.py,sha256=BtnlzLm8JcCL8suDUXf5m-ShCosrOFgAbL2qT5t6atM,35648
-modularitypruning/partition_utilities.py,sha256=_QAFKPUQlt-v_D7fydu-CbPvFZM9lw3qpxfX09Gv7Zw,1914
-modularitypruning/plotting.py,sha256=eQkqmx1fEfiT9AtYo1l63cm8B2I914I3XScoQv0UjhY,12249
-modularitypruning/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-modularitypruning/types.py,sha256=VdaNyxaqEFeJJuIp14X-pvv893yTfbxnq5MepBQEui4,2444
-modularitypruning-2.0.0.dist-info/licenses/LICENSE,sha256=eWz3HIQQxg7p1iSpUOUDKdDhGcuMPuVDDlcXf9F12D8,1068
-modularitypruning-2.0.0.dist-info/METADATA,sha256=Sx24A8K9GupCvLgBOepaMFJPV_FmhavGI_TA-ccGyLs,3972
-modularitypruning-2.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-modularitypruning-2.0.0.dist-info/top_level.txt,sha256=ZPOx3a-ek0Ge0ZMq-uvbySSaAL9MZ-t23-JkuHZXo9E,18
-modularitypruning-2.0.0.dist-info/RECORD,,