put-asunder 0.1.0__tar.gz

put_asunder-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License for Asunder
+
+Copyright (c) 2026, Allman Process Systems Research Team, University of Michigan
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

put_asunder-0.1.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: put-asunder
+Version: 0.1.0
+Summary: Asunder: Constrained Structure Detection on Undirected Graphs.
+Author-email: Fortune Adekogbe <fortunea@umich.edu>, Allman Group <allmanaa@umich.edu>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/allman-group/asunder
+Project-URL: Documentation, https://put-asunder.readthedocs.io
+Project-URL: Repository, https://github.com/allman-group/asunder
+Keywords: graph,constrained-clustering,graph-clustering,community-detection,core-periphery,column-generation,constrained-network-structure-detection,branch-and-price
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Intended Audience :: Science/Research
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.13
+Requires-Dist: networkx>=3.2
+Requires-Dist: scikit-learn>=1.5
+Requires-Dist: scikit-network>=0.33
+Requires-Dist: tqdm>=4.66
+Requires-Dist: pyomo>=6.8
+Requires-Dist: gurobipy>=11.0
+Provides-Extra: graph
+Requires-Dist: python-igraph>=0.11; extra == "graph"
+Requires-Dist: leidenalg>=0.10; extra == "graph"
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.8; extra == "viz"
+Requires-Dist: seaborn>=0.13; extra == "viz"
+Provides-Extra: legacy
+Requires-Dist: cpnet; extra == "legacy"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.4; extra == "docs"
+Requires-Dist: furo>=2024.8.6; extra == "docs"
+Requires-Dist: myst-parser>=3.0; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=2.3; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.7; extra == "dev"
+Requires-Dist: mypy>=1.12; extra == "dev"
+Requires-Dist: pre-commit>=3.8; extra == "dev"
+Dynamic: license-file
+
+# Asunder
+
+Asunder is a Python package for constrained structure detection on undirected graphs, with workflows centered on column generation and customizable master/subproblem pipelines.
+
+Development of Asunder is led by the Allman Group at the University of Michigan.
+
+## Install
+
+Base install:
+
+```bash
+pip install put-asunder
+```
+
+Optional extras:
+
+```bash
+pip install "put-asunder[graph,viz]"
+```
+
+Legacy heuristics (best-effort on Python 3.13):
+
+```bash
+pip install "put-asunder[legacy]"
+```
+
+## Python Support
+
+- Guaranteed: Python 3.10, 3.11, 3.12, 3.13 for core package.
+- Guaranteed: mainstream extras (`graph`, `viz`) on Python 3.10–3.13.
+- Best-effort: `legacy` extra on Python 3.13.
+
+## Quickstart
+
+```python
+import numpy as np
+from asunder import CSDDecomposition, CSDDecompositionConfig
+
+A = np.array([
+    [0, 1, 1, 0],
+    [1, 0, 1, 0],
+    [1, 1, 0, 0],
+    [0, 0, 0, 0],
+], dtype=float)
+
+cfg = CSDDecompositionConfig(
+    ifc_params={"generator": lambda N, **_: [np.ones((N, N))], "num": 1, "args": {"N": A.shape[0]}},
+    extract_dual=False,
+    final_master_solve=False,
+)
+
+result = CSDDecomposition(config=cfg).run(A)
+print(result.metadata)
+```
+
+## Solver Setup
+
+Asunder accepts user-provided solver objects. For Gurobi, `GRB_LICENSE_FILE` is used by your environment. Example:
+
+```python
+from asunder import create_solver
+
+solver = create_solver("gurobi_direct")
+```
+
+## Problem Fit
+
+Asunder works well out of the box for optimization problems where coordination or operations are coupled across time and those interactions can be represented as a graph over constraints.
+
+Asunder also supports general constrained partitioning beyond these domain examples when requirements can be expressed as must-link and cannot-link constraints.
+
+Typical fit signals:
+
+- coupling across time periods, units, or resources
+- mixed discrete-continuous structure with meaningful constraint interactions
+- a useful interpretation of must-link/cannot-link or worthy-edge constraints
+- value from multilevel partitioning or core-periphery structure detection
+
+Representative domains:
+
+- stochastic design and dispatch in energy systems
+- scheduling and resource allocation in healthcare systems
+- planning, routing, and location in supply chain and logistics
+- network configuration and resource management in telecommunications
+
+For a fuller guide on where default workflows are sufficient vs where customization helps, see `docs/problem_fit.rst`.
+
+## Constraint Graph Compatibility
+
+For the built-in case-study evaluation workflows (`run_evaluation`), Asunder expects a constraint-graph pattern consistent with the provided case studies.
+
+Required structure for `run_evaluation`-style workflows:
+
+- undirected graph (typically `networkx.Graph`)
+- node attribute `constraint` (string tag used for ground-truth and role grouping)
+- edge attribute `var_type` with values `"integer"` or `"continuous"`
+
+Commonly present (recommended) attributes:
+
+- node attribute `type` (for example `"constraint"`)
+- node attribute `details` (metadata dict)
+- edge attributes `weight`, `variables`, `var_types`
+
+How these are used:
+
+- `constraint` identifies core/nonlinear tags in built-in case studies
+- `var_type` determines candidate edge sets for CP and CD_Refine paths
+
+If you are not using `run_evaluation` and instead calling decomposition APIs directly, you can work from an adjacency matrix plus explicit `must_link`, `cannot_link`, and optional `worthy_edges`.
+
+## Customization Points
+
+For custom problems, typical extension points are:
+
+1. Initial feasible partition generator.
+2. `solve_master_problem` replacement.
+3. Heuristic or ILP subproblem replacement.
+4. Optional partition refinement stage.
+
+## Examples
+
+- Nonlinear B&P-style decomposition: `examples/nonlinear_bp.py`
+- Custom subproblem wiring: `examples/custom_subproblem.py`
+
+## Documentation
+
+Sphinx docs are scaffolded in `docs/` and intended for Read the Docs deployment.
+
+## References
+
+Asunder integrates or wraps methods from:
+
+- python-igraph / leidenalg
+- scikit-network
+- signed-louvain style algorithms

put_asunder-0.1.0/README.md

@@ -0,0 +1,135 @@
+# Asunder
+
+Asunder is a Python package for constrained structure detection on undirected graphs, with workflows centered on column generation and customizable master/subproblem pipelines.
+
+Development of Asunder is led by the Allman Group at the University of Michigan.
+
+## Install
+
+Base install:
+
+```bash
+pip install put-asunder
+```
+
+Optional extras:
+
+```bash
+pip install "put-asunder[graph,viz]"
+```
+
+Legacy heuristics (best-effort on Python 3.13):
+
+```bash
+pip install "put-asunder[legacy]"
+```
+
+## Python Support
+
+- Guaranteed: Python 3.10, 3.11, 3.12, 3.13 for core package.
+- Guaranteed: mainstream extras (`graph`, `viz`) on Python 3.10–3.13.
+- Best-effort: `legacy` extra on Python 3.13.
+
+## Quickstart
+
+```python
+import numpy as np
+from asunder import CSDDecomposition, CSDDecompositionConfig
+
+A = np.array([
+    [0, 1, 1, 0],
+    [1, 0, 1, 0],
+    [1, 1, 0, 0],
+    [0, 0, 0, 0],
+], dtype=float)
+
+cfg = CSDDecompositionConfig(
+    ifc_params={"generator": lambda N, **_: [np.ones((N, N))], "num": 1, "args": {"N": A.shape[0]}},
+    extract_dual=False,
+    final_master_solve=False,
+)
+
+result = CSDDecomposition(config=cfg).run(A)
+print(result.metadata)
+```
+
+## Solver Setup
+
+Asunder accepts user-provided solver objects. For Gurobi, `GRB_LICENSE_FILE` is used by your environment. Example:
+
+```python
+from asunder import create_solver
+
+solver = create_solver("gurobi_direct")
+```
+
+## Problem Fit
+
+Asunder works well out of the box for optimization problems where coordination or operations are coupled across time and those interactions can be represented as a graph over constraints.
+
+Asunder also supports general constrained partitioning beyond these domain examples when requirements can be expressed as must-link and cannot-link constraints.
+
+Typical fit signals:
+
+- coupling across time periods, units, or resources
+- mixed discrete-continuous structure with meaningful constraint interactions
+- a useful interpretation of must-link/cannot-link or worthy-edge constraints
+- value from multilevel partitioning or core-periphery structure detection
+
+Representative domains:
+
+- stochastic design and dispatch in energy systems
+- scheduling and resource allocation in healthcare systems
+- planning, routing, and location in supply chain and logistics
+- network configuration and resource management in telecommunications
+
+For a fuller guide on where default workflows are sufficient vs where customization helps, see `docs/problem_fit.rst`.
+
+## Constraint Graph Compatibility
+
+For the built-in case-study evaluation workflows (`run_evaluation`), Asunder expects a constraint-graph pattern consistent with the provided case studies.
+
+Required structure for `run_evaluation`-style workflows:
+
+- undirected graph (typically `networkx.Graph`)
+- node attribute `constraint` (string tag used for ground-truth and role grouping)
+- edge attribute `var_type` with values `"integer"` or `"continuous"`
+
+Commonly present (recommended) attributes:
+
+- node attribute `type` (for example `"constraint"`)
+- node attribute `details` (metadata dict)
+- edge attributes `weight`, `variables`, `var_types`
+
+How these are used:
+
+- `constraint` identifies core/nonlinear tags in built-in case studies
+- `var_type` determines candidate edge sets for CP and CD_Refine paths
+
+If you are not using `run_evaluation` and instead calling decomposition APIs directly, you can work from an adjacency matrix plus explicit `must_link`, `cannot_link`, and optional `worthy_edges`.
+
+## Customization Points
+
+For custom problems, typical extension points are:
+
+1. Initial feasible partition generator.
+2. `solve_master_problem` replacement.
+3. Heuristic or ILP subproblem replacement.
+4. Optional partition refinement stage.
+
+## Examples
+
+- Nonlinear B&P-style decomposition: `examples/nonlinear_bp.py`
+- Custom subproblem wiring: `examples/custom_subproblem.py`
+
+## Documentation
+
+Sphinx docs are scaffolded in `docs/` and intended for Read the Docs deployment.
+
+## References
+
+Asunder integrates or wraps methods from:
+
+- python-igraph / leidenalg
+- scikit-network
+- signed-louvain style algorithms

put_asunder-0.1.0/asunder/__init__.py

@@ -0,0 +1,32 @@
+"""Asunder: Constrained structure detection on undirected graphs."""
+
+from asunder.column_generation.master import solve_master_problem
+from asunder.column_generation.subproblem import solve_subproblem
+from asunder.config import CSDDecompositionConfig
+from asunder.orchestrator import CSDDecomposition, run_csd_decomposition
+from asunder.solvers import create_solver
+from asunder.types import DecompositionResult, IterationRecord
+
+
+def run_evaluation(*args, **kwargs):
+    """Run benchmark evaluations using :mod:`asunder.evaluation.runner`.
+
+    This lazy import keeps optional evaluation dependencies out of import-time
+    paths for users who only need decomposition APIs.
+    """
+    from asunder.evaluation.runner import run_evaluation as _run_evaluation
+
+    return _run_evaluation(*args, **kwargs)
+
+
+__all__ = [
+    "CSDDecomposition",
+    "CSDDecompositionConfig",
+    "DecompositionResult",
+    "IterationRecord",
+    "create_solver",
+    "run_csd_decomposition",
+    "run_evaluation",
+    "solve_master_problem",
+    "solve_subproblem",
+]

put_asunder-0.1.0/asunder/algorithms/__init__.py

@@ -0,0 +1,22 @@
+"""Public algorithm exports for community and core-periphery detection."""
+
+from asunder.algorithms.community import run_modularity, run_signed_louvain
+from asunder.algorithms.core_periphery import (
+    EnhancedGeneticBE,
+    FullContinuousGeneticBE,
+    detect_continuous_KL,
+    find_core,
+    spectral_continuous_cp_detection,
+)
+from asunder.algorithms.louvain_modified import ModifiedLouvain
+
+__all__ = [
+    "EnhancedGeneticBE",
+    "FullContinuousGeneticBE",
+    "ModifiedLouvain",
+    "detect_continuous_KL",
+    "spectral_continuous_cp_detection",
+    "find_core",
+    "run_modularity",
+    "run_signed_louvain",
+]

put_asunder-0.1.0/asunder/algorithms/community.py

@@ -0,0 +1,285 @@
+"""Community-detection helpers and wrappers."""
+
+from __future__ import annotations
+
+import itertools
+
+import networkx as nx
+import numpy as np
+from scipy import sparse
+
+from asunder.algorithms.signed_louvain import community_detection as cd
+from asunder.algorithms.signed_louvain import util as slouvain_util
+from asunder.utils.graph import (
+    group_nodes_by_community,
+    partition_matrix_to_vector,
+    partition_vector_to_2d_matrix,
+)
+
+
+def _import_sknetwork():
+    from sknetwork.clustering import Leiden, Louvain, PropagationClustering, get_modularity
+    from sknetwork.linalg import normalize
+    from sknetwork.utils import get_membership
+
+    return Louvain, Leiden, PropagationClustering, get_modularity, normalize, get_membership
+
+
+def _import_igraph():
+    import igraph as ig
+
+    return ig
+
+
+def _import_leidenalg():
+    import leidenalg as la
+
+    return la
+
+def labels_to_probabilities(A, labels, p=1):
+    """Convert hard labels into row-normalized membership probabilities."""
+    _, _, _, _, normalize, get_membership = _import_sknetwork()
+    if not sparse.isspmatrix_csr(A):
+        A = sparse.csr_matrix(np.asarray(A), dtype=float)
+    M = get_membership(labels)
+    return normalize(A @ M, p=p)
+
+
+def probability_to_integer_labels(probabilities, method="threshold", threshold=0.8, verbose=False):
+    """Map soft memberships to integer labels using a configurable rule."""
+    from sklearn.cluster import DBSCAN
+    from sklearn.mixture import GaussianMixture
+
+    assert method in ["threshold", "gaussian_mixture", "DBSCAN"]
+
+    if probabilities.ndim == 2:
+        p = np.max(probabilities, axis=1).reshape((-1, 1))
+    else:
+        p = probabilities.reshape((-1, 1))
+    scaled_probabilities = (probabilities - p.min()) / (p.max() - p.min() + 1e-12)
+    scaled_probabilities[scaled_probabilities < 0] = 0
+
+    if verbose:
+        print("Probability values are:\n", p)
+    partition = np.zeros(shape=(probabilities.shape[0],))
+
+    if method == "threshold":
+        for i in range(probabilities.shape[0]):
+            if np.max(probabilities[i]) < threshold:
+                partition[i] = -1
+            else:
+                partition[i] = np.argmax(probabilities[i])
+    elif method == "gaussian_mixture":
+        gmm = GaussianMixture(n_components=2, random_state=42)
+        labels_gmm = gmm.fit_predict(p)
+        core_cluster = np.argmin(gmm.means_)
+        if verbose:
+            print("Labels from GMM are:\n", labels_gmm)
+        for i in range(probabilities.shape[0]):
+            if labels_gmm[i] == core_cluster:
+                partition[i] = -1
+            else:
+                partition[i] = np.argmax(probabilities[i])
+    else:
+        labels_dbscan = DBSCAN().fit_predict(
+            scaled_probabilities if (np.std(np.unique(p)) < 0.25) else probabilities
+        )
+        v, c = np.unique(labels_dbscan, return_counts=True)
+        lv = v[np.argmin(c)]
+        for i in range(probabilities.shape[0]):
+            if labels_dbscan[i] == lv:
+                partition[i] = -1
+            else:
+                partition[i] = np.argmax(probabilities[i])
+    return partition
+
+
+def refine_partition_linear_group(
+    A, partition, *, p=1, prob_method="threshold", threshold=0.8, verbose=False
+):
+    """Refine a partition by reassigning low-confidence nodes."""
+    labels = partition_matrix_to_vector(partition) if partition.ndim == 2 else partition.copy()
+    probs = labels_to_probabilities(A, labels, p=p).toarray()
+    refined_labels = probability_to_integer_labels(
+        probs, method=prob_method, threshold=threshold, verbose=verbose
+    )
+    return partition_vector_to_2d_matrix(refined_labels)
+
+
+def best_girvan_newman_partition(G, max_levels=10):
+    """Search Girvan-Newman levels and return the best modularity partition."""
+    comp = nx.community.girvan_newman(G)
+    best_mod = -1.0
+    best_communities = None
+    for communities in itertools.islice(comp, max_levels):
+        communities_list = tuple(sorted(c) for c in communities)
+        mod = nx.community.modularity(G, communities_list)
+        if mod > best_mod:
+            best_mod = mod
+            best_communities = communities_list
+    return best_communities, best_mod
+
+
+def run_modularity(modified_A, algo="louvain", package="networkx", resolution=1, verbose=False, refine=True, refine_params=None):
+    """Run modularity-style community detection and return ``(partition, score)``."""
+    assert algo in ["louvain", "leiden", "greedy", "girvan_newman"]
+    modG = nx.from_numpy_array(modified_A.astype([("weight", "float")]))
+    metric = None
+
+    if package in {"igraph", "leidenalg"}:
+        ig = _import_igraph()
+        ig_graph = ig.Graph.Weighted_Adjacency(modified_A.tolist(), mode="UNDIRECTED", attr="weight")
+    else:
+        ig_graph = None
+
+    if algo == "louvain":
+        if package == "networkx":
+            communities = nx.community.louvain_communities(modG, weight="weight", resolution=resolution)
+        elif package == "sknetwork":
+            Louvain, _, _, _, _, _ = _import_sknetwork()
+            partition = Louvain().fit_predict(modified_A)
+            communities = {}
+            for i, val in enumerate(partition):
+                communities.setdefault(val, set()).add(int(i))
+            communities = communities.values()
+        else:
+            raise NotImplementedError(f"Invalid package: {package}")
+    elif algo == "leiden":
+        if package == "leidenalg":
+            la = _import_leidenalg()
+            partition = la.find_partition(
+                ig_graph, la.ModularityVertexPartition, seed=42, weights="weight"
+            )
+            membership = {}
+            for node, comm in zip(ig_graph.vs.indices, partition.membership):
+                membership.setdefault(comm, []).append(node)
+            communities = list(membership.values())
+        elif package == "sknetwork":
+            _, Leiden, _, _, _, _ = _import_sknetwork()
+            partition = Leiden().fit_predict(modified_A)
+            communities = {}
+            for i, val in enumerate(partition):
+                communities.setdefault(val, set()).add(int(i))
+            communities = communities.values()
+        elif package == "igraph":
+            clustering = ig_graph.community_leiden(
+                objective_function="modularity", weights="weight", resolution=resolution
+            )
+            communities = {}
+            for i, val in enumerate(clustering.membership):
+                communities.setdefault(val, set()).add(int(i))
+            communities = communities.values()
+        else:
+            raise NotImplementedError(f"Invalid package: {package}")
+    elif algo == "greedy":
+        if package == "networkx":
+            communities = nx.community.greedy_modularity_communities(
+                modG, weight="weight", resolution=resolution
+            )
+        elif package == "igraph":
+            clustering = ig_graph.community_fastgreedy(weights="weight").as_clustering()
+            communities = {}
+            for i, val in enumerate(clustering.membership):
+                communities.setdefault(val, set()).add(int(i))
+            communities = communities.values()
+        else:
+            raise NotImplementedError(f"Invalid package: {package}")
+    else:
+        communities, _ = best_girvan_newman_partition(modG, max_levels=modified_A.shape[0])
+
+    oneD_z = np.zeros(shape=(modified_A.shape[0]), dtype=np.int64)
+    for i, community in enumerate(communities):
+        for node in community:
+            oneD_z[node] = i
+
+    if refine:
+        if refine_params is None:
+            raise ValueError("refine_params is required when refine=True")
+        zii = refine_params["refine_func"](A=modified_A, partition=oneD_z, **refine_params["kwargs"])
+        _, communities = group_nodes_by_community(np.array(zii))
+    else:
+        zii = np.equal.outer(oneD_z, oneD_z).astype(int)
+    metric = nx.community.modularity(modG, communities)
+    return zii, metric
+
+
+def run_lpa(modified_A, refine=True):
+    """Run label propagation clustering and return ``(partition, modularity)``."""
+    _, _, PropagationClustering, get_modularity, _, _ = _import_sknetwork()
+    algorithm = PropagationClustering()
+    if refine:
+        result = algorithm.fit_predict_proba(modified_A)
+        partition = np.zeros(shape=(result.shape[0],))
+        for i in range(result.shape[0]):
+            partition[i] = -1 if np.max(result[i]) < 0.8 else np.argmax(result[i])
+    else:
+        partition = algorithm.fit_predict(modified_A)
+
+    communities = {}
+    for i, val in enumerate(partition):
+        communities.setdefault(val, set()).add(int(i))
+    oneD_z = np.zeros(shape=(modified_A.shape[0]), dtype=np.int64)
+    for i, community in enumerate(communities.values()):
+        for node in community:
+            oneD_z[node] = i
+    zii = np.equal.outer(oneD_z, oneD_z).astype(int)
+    return zii, get_modularity(modified_A, partition.astype(int))
+
+
+def run_igraph_spinglass(modified_A):
+    """Run igraph spinglass community detection and return a partition matrix."""
+    ig = _import_igraph()
+    ig_graph = ig.Graph.Weighted_Adjacency(modified_A.tolist(), mode="UNDIRECTED", attr="weight")
+    clustering = ig_graph.community_spinglass(
+        weights="weight", implementation="neg", lambda_=0.0, spins=500, start_temp=1.0, stop_temp=0.01, cool_fact=0.99
+    )
+    oneD_z = clustering.membership
+    return np.equal.outer(oneD_z, oneD_z).astype(int)
+
+
+def run_igraph(modified_A, algo="infomap", resolution=1):
+    """Run selected igraph community algorithm and return ``(partition, score)``."""
+    ig = _import_igraph()
+    ig_graph = ig.Graph.Weighted_Adjacency(modified_A.tolist(), mode="UNDIRECTED", attr="weight")
+    if algo == "infomap":
+        clustering = ig_graph.community_infomap(edge_weights="weight")
+    elif algo == "lpa":
+        clustering = ig_graph.community_label_propagation(weights="weight")
+    elif algo == "multilevel":
+        clustering = ig_graph.community_multilevel(weights="weight", resolution=resolution)
+    elif algo == "voronoi":
+        clustering = ig_graph.community_voronoi(weights="weight", radius=resolution)
+    elif algo == "walktrap":
+        clustering = ig_graph.community_walktrap(weights="weight").as_clustering()
+    else:
+        raise NotImplementedError("Invalid Igraph Algorithm")
+    oneD_z = clustering.membership
+    zii = np.equal.outer(oneD_z, oneD_z).astype(int)
+    metric = ig_graph.modularity(clustering, weights="weight", resolution=resolution)
+    return zii, metric
+
+
+def run_signed_louvain(modified_A):
+    """Run signed Louvain on positive/negative layers and return ``(partition, score)``."""
+    n_nodes = modified_A.shape[0]
+    edges = [(i, j, modified_A[i, j]) for i, j in zip(*np.where(np.triu(modified_A) != 0))]
+    graph = slouvain_util.build_nx_graph(n_nodes, edges)
+    posgraph, neggraph = slouvain_util.build_subgraphs(graph, weight="weight")
+    communities, status = cd.best_partition(
+        layers=[posgraph, neggraph],
+        layer_weights=[1.0, -1.0],
+        resolutions=[1.0, 1.0],
+        masks=[False, True],
+        k=2,
+        initial_membership=None,
+        weight="weight",
+        random_state=None,
+        pass_max=40,
+        return_dendogram=False,
+        silent=True,
+    )
+    oneD_z = np.zeros(shape=(modified_A.shape[0]), dtype=np.int64)
+    for node, community in communities.items():
+        oneD_z[node] = community
+    zii = np.equal.outer(oneD_z, oneD_z).astype(int)
+    return zii, status.modularity()