risk-network 0.0.9b8__py3-none-any.whl → 0.0.9b11__py3-none-any.whl

risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.9-beta.8"
+__version__ = "0.0.9-beta.11"

risk/neighborhoods/community.py

@@ -4,10 +4,12 @@ risk/neighborhoods/community
 """
 
 import community as community_louvain
+import igraph as ig
+import markov_clustering as mc
 import networkx as nx
 import numpy as np
-import markov_clustering as mc
-from networkx.algorithms.community import asyn_lpa_communities, greedy_modularity_communities
+from leidenalg import find_partition, RBConfigurationVertexPartition
+from networkx.algorithms.community import greedy_modularity_communities
 
 
 def calculate_greedy_modularity_neighborhoods(network: nx.Graph) -> np.ndarray:
@@ -21,18 +23,19 @@ def calculate_greedy_modularity_neighborhoods(network: nx.Graph) -> np.ndarray:
     """
     # Detect communities using the Greedy Modularity method
     communities = greedy_modularity_communities(network)
+    # Get the list of nodes in the original NetworkX graph
+    nodes = list(network.nodes())
+    node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
-    n_nodes = network.number_of_nodes()
+    n_nodes = len(nodes)
     neighborhoods = np.zeros((n_nodes, n_nodes), dtype=int)
-    # Create a mapping from node to index in the matrix
-    node_index = {node: i for i, node in enumerate(network.nodes())}
     # Fill in the neighborhood matrix for nodes in the same community
     for community in communities:
         # Iterate through all pairs of nodes in the same community
         for node_i in community:
-            idx_i = node_index[node_i]
             for node_j in community:
-                idx_j = node_index[node_j]
+                idx_i = node_index_map[node_i]
+                idx_j = node_index_map[node_j]
                 # Set them as neighbors (1) in the binary matrix
                 neighborhoods[idx_i, idx_j] = 1
 
@@ -46,21 +49,61 @@ def calculate_label_propagation_neighborhoods(network: nx.Graph) -> np.ndarray:
         network (nx.Graph): The network graph.
 
     Returns:
-        np.ndarray: Binary neighborhood matrix on Label Propagation.
+        np.ndarray: A binary neighborhood matrix on Label Propagation.
     """
     # Apply Label Propagation for community detection
     communities = nx.algorithms.community.label_propagation.label_propagation_communities(network)
+    # Get the list of nodes in the network
+    nodes = list(network.nodes())
+    node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
-    num_nodes = network.number_of_nodes()
+    num_nodes = len(nodes)
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Create a mapping from node to index in the matrix
-    node_index = {node: i for i, node in enumerate(network.nodes())}
-    # Assign neighborhoods based on community labels
+    # Assign neighborhoods based on community labels using the mapped indices
     for community in communities:
         for node_i in community:
-            idx_i = node_index[node_i]
             for node_j in community:
-                idx_j = node_index[node_j]
+                idx_i = node_index_map[node_i]
+                idx_j = node_index_map[node_j]
+                neighborhoods[idx_i, idx_j] = 1
+
+    return neighborhoods
+
+
+def calculate_leiden_neighborhoods(
+    network: nx.Graph, resolution: float = 1.0, random_seed: int = 888
+) -> np.ndarray:
+    """Calculate neighborhoods using the Leiden method.
+
+    Args:
+        network (nx.Graph): The network graph.
+        resolution (float, optional): Resolution parameter for the Leiden method. Defaults to 1.0.
+        random_seed (int, optional): Random seed for reproducibility. Defaults to 888.
+
+    Returns:
+        np.ndarray: A binary neighborhood matrix where nodes in the same community have 1, and others have 0.
+    """
+    # Convert NetworkX graph to iGraph
+    igraph_network = ig.Graph.from_networkx(network)
+    # Apply Leiden algorithm using RBConfigurationVertexPartition, which supports resolution
+    partition = find_partition(
+        igraph_network,
+        partition_type=RBConfigurationVertexPartition,
+        resolution_parameter=resolution,
+        seed=random_seed,
+    )
+    # Get the list of nodes in the original NetworkX graph
+    nodes = list(network.nodes())
+    node_index_map = {node: idx for idx, node in enumerate(nodes)}
+    # Create a binary neighborhood matrix
+    num_nodes = len(nodes)
+    neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+    # Assign neighborhoods based on community partitions using the mapped indices
+    for community in partition:
+        for node_i in community:
+            for node_j in community:
+                idx_i = node_index_map[igraph_network.vs[node_i]["_nx_name"]]
+                idx_j = node_index_map[igraph_network.vs[node_j]["_nx_name"]]
                 neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
@@ -77,28 +120,29 @@ def calculate_louvain_neighborhoods(
         random_seed (int, optional): Random seed for reproducibility. Defaults to 888.
 
     Returns:
-        np.ndarray: Binary neighborhood matrix on the Louvain method.
+        np.ndarray: A binary neighborhood matrix on the Louvain method.
     """
     # Apply Louvain method to partition the network
     partition = community_louvain.best_partition(
         network, resolution=resolution, random_state=random_seed
     )
+    # Get the list of nodes in the network and create a mapping to indices
+    nodes = list(network.nodes())
+    node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
-    num_nodes = network.number_of_nodes()
+    num_nodes = len(nodes)
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Create a mapping from node to index in the matrix
-    node_index = {node: i for i, node in enumerate(network.nodes())}
     # Group nodes by community
     community_groups = {}
     for node, community in partition.items():
         community_groups.setdefault(community, []).append(node)
 
-    # Assign neighborhoods based on community partitions
+    # Assign neighborhoods based on community partitions using the mapped indices
     for community, nodes in community_groups.items():
         for node_i in nodes:
-            idx_i = node_index[node_i]
             for node_j in nodes:
-                idx_j = node_index[node_j]
+                idx_i = node_index_map[node_i]
+                idx_j = node_index_map[node_j]
                 neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
@@ -111,53 +155,76 @@ def calculate_markov_clustering_neighborhoods(network: nx.Graph) -> np.ndarray:
         network (nx.Graph): The network graph.
 
     Returns:
-        np.ndarray: Binary neighborhood matrix on Markov Clustering.
+        np.ndarray: A binary neighborhood matrix on Markov Clustering.
     """
-    # Convert the graph to an adjacency matrix
-    adjacency_matrix = nx.to_numpy_array(network)
-    # Run Markov Clustering (MCL)
-    result = mc.run_mcl(adjacency_matrix)  # MCL with default parameters
-    # Get clusters (communities) from MCL result
+    # Step 1: Convert the graph to an adjacency matrix
+    nodes = list(network.nodes())
+    node_index_map = {node: idx for idx, node in enumerate(nodes)}
+    # Step 2: Create a reverse mapping from index to node
+    index_node_map = {idx: node for node, idx in node_index_map.items()}
+    adjacency_matrix = nx.to_numpy_array(network, nodelist=nodes)
+    # Step 3: Run Markov Clustering (MCL) on the adjacency matrix
+    result = mc.run_mcl(adjacency_matrix)
+    # Step 4: Get clusters (communities) from MCL result
     clusters = mc.get_clusters(result)
-    # Create a binary neighborhood matrix
-    num_nodes = network.number_of_nodes()
+    # Step 5: Create a binary neighborhood matrix
+    num_nodes = len(nodes)
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Create a mapping from node to index in the matrix
-    node_index = {node: i for i, node in enumerate(network.nodes())}
-    # Assign neighborhoods based on MCL clusters
+    # Step 6: Assign neighborhoods based on MCL clusters using the original node labels
     for cluster in clusters:
         for node_i in cluster:
-            idx_i = node_index[node_i]
             for node_j in cluster:
-                idx_j = node_index[node_j]
+                # Map the matrix indices back to the original node labels
+                original_node_i = index_node_map[node_i]
+                original_node_j = index_node_map[node_j]
+                idx_i = node_index_map[original_node_i]
+                idx_j = node_index_map[original_node_j]
                 neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
 
 
 def calculate_spinglass_neighborhoods(network: nx.Graph) -> np.ndarray:
-    """Apply Spin Glass Community Detection to the network.
+    """Apply Spinglass Community Detection to the network, handling disconnected components.
 
     Args:
-        network (nx.Graph): The network graph.
+        network (nx.Graph): The input network graph with 'x' and 'y' attributes for node positions.
 
     Returns:
-        np.ndarray: Binary neighborhood matrix on Spin Glass communities.
+        np.ndarray: A binary neighborhood matrix based on Spinglass communities.
     """
-    # Apply Asynchronous Label Propagation (LPA)
-    communities = asyn_lpa_communities(network)
-    # Create a binary neighborhood matrix
-    num_nodes = network.number_of_nodes()
+    # Step 1: Find connected components in the graph
+    components = list(nx.connected_components(network))
+    # Prepare to store community results
+    nodes = list(network.nodes())
+    node_index_map = {node: idx for idx, node in enumerate(nodes)}
+    num_nodes = len(nodes)
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Create a mapping from node to index in the matrix
-    node_index = {node: i for i, node in enumerate(network.nodes())}
-    # Assign neighborhoods based on community labels from LPA
-    for community in communities:
-        for node_i in community:
-            idx_i = node_index[node_i]
-            for node_j in community:
-                idx_j = node_index[node_j]
-                neighborhoods[idx_i, idx_j] = 1
+    # Step 2: Run Spinglass on each connected component
+    for component in components:
+        # Extract the subgraph corresponding to the current component
+        subgraph = network.subgraph(component)
+        # Convert the subgraph to an iGraph object
+        igraph_subgraph = ig.Graph.from_networkx(subgraph)
+        # Ensure the subgraph is connected before running Spinglass
+        if not igraph_subgraph.is_connected():
+            print("Warning: Subgraph is not connected. Skipping...")
+            continue
+
+        # Apply Spinglass community detection
+        try:
+            communities = igraph_subgraph.community_spinglass()
+        except Exception as e:
+            print(f"Error running Spinglass on component: {e}")
+            continue
+
+        # Step 3: Assign neighborhoods based on community labels
+        for community in communities:
+            for node_i in community:
+                for node_j in community:
+                    idx_i = node_index_map[igraph_subgraph.vs[node_i]["_nx_name"]]
+                    idx_j = node_index_map[igraph_subgraph.vs[node_j]["_nx_name"]]
+                    neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
 
@@ -169,21 +236,24 @@ def calculate_walktrap_neighborhoods(network: nx.Graph) -> np.ndarray:
         network (nx.Graph): The network graph.
 
     Returns:
-        np.ndarray: Binary neighborhood matrix on Walktrap communities.
+        np.ndarray: A binary neighborhood matrix on Walktrap communities.
     """
-    # Apply Asynchronous Label Propagation (LPA)
-    communities = asyn_lpa_communities(network)
+    # Convert NetworkX graph to iGraph
+    igraph_network = ig.Graph.from_networkx(network)
+    # Apply Walktrap community detection
+    communities = igraph_network.community_walktrap().as_clustering()
+    # Get the list of nodes in the original NetworkX graph
+    nodes = list(network.nodes())
+    node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
-    num_nodes = network.number_of_nodes()
+    num_nodes = len(nodes)
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Create a mapping from node to index in the matrix
-    node_index = {node: i for i, node in enumerate(network.nodes())}
-    # Assign neighborhoods based on community labels from LPA
+    # Assign neighborhoods based on community labels
     for community in communities:
         for node_i in community:
-            idx_i = node_index[node_i]
             for node_j in community:
-                idx_j = node_index[node_j]
+                idx_i = node_index_map[igraph_network.vs[node_i]["_nx_name"]]
+                idx_j = node_index_map[igraph_network.vs[node_j]["_nx_name"]]
                 neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods

risk/neighborhoods/neighborhoods.py

@@ -15,6 +15,7 @@ from sklearn.metrics.pairwise import cosine_similarity
 from risk.neighborhoods.community import (
     calculate_greedy_modularity_neighborhoods,
     calculate_label_propagation_neighborhoods,
+    calculate_leiden_neighborhoods,
     calculate_louvain_neighborhoods,
     calculate_markov_clustering_neighborhoods,
     calculate_spinglass_neighborhoods,
@@ -29,22 +30,20 @@ warnings.filterwarnings(action="ignore", category=DataConversionWarning)
 def get_network_neighborhoods(
     network: nx.Graph,
     distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
-    edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 1.0,
-    louvain_resolution: float = 1.0,
+    edge_rank_percentile: Union[float, List, Tuple, np.ndarray] = 1.0,
+    louvain_resolution: float = 0.1,
+    leiden_resolution: float = 1.0,
     random_seed: int = 888,
 ) -> np.ndarray:
     """Calculate the combined neighborhoods for each node based on the specified community detection algorithm(s).
 
     Args:
         network (nx.Graph): The network graph.
-        distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use. Can be a string for one
-            metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
-            'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
-        edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
-            Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
-            Defaults to 1.0.
-        louvain_resolution (float, optional): Resolution parameter for the Louvain method. Defaults to 1.0.
-        random_seed (int, optional): Random seed for methods requiring random initialization. Defaults to 888.
+        distance_metric (str, List, Tuple, or np.ndarray, optional): The distance metric(s) to use.
+        edge_rank_percentile (float, List, Tuple, or np.ndarray, optional): Shortest edge rank percentile threshold(s) for creating subgraphs.
+        louvain_resolution (float, optional): Resolution parameter for the Louvain method.
+        leiden_resolution (float, optional): Resolution parameter for the Leiden method.
+        random_seed (int, optional): Random seed for methods requiring random initialization.
 
     Returns:
         np.ndarray: Summed neighborhood matrix from all selected algorithms.
@@ -53,14 +52,13 @@ def get_network_neighborhoods(
     random.seed(random_seed)
     np.random.seed(random_seed)
 
-    # Ensure distance_metric is a list/tuple for multi-algorithm handling
+    # Ensure distance_metric and edge_rank_percentile are lists
     if isinstance(distance_metric, (str, np.ndarray)):
         distance_metric = [distance_metric]
-    # Ensure edge_length_threshold is a list/tuple for multi-threshold handling
-    if isinstance(edge_length_threshold, (float, int)):
-        edge_length_threshold = [edge_length_threshold] * len(distance_metric)
-    # Check that the number of distance metrics matches the number of edge length thresholds
-    if len(distance_metric) != len(edge_length_threshold):
+    if isinstance(edge_rank_percentile, (float, int)):
+        edge_rank_percentile = [edge_rank_percentile] * len(distance_metric)
+
+    if len(distance_metric) != len(edge_rank_percentile):
         raise ValueError(
             "The number of distance metrics must match the number of edge length thresholds."
         )
@@ -70,80 +68,114 @@ def get_network_neighborhoods(
     combined_neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
 
     # Loop through each distance metric and corresponding edge length threshold
-    for metric, threshold in zip(distance_metric, edge_length_threshold):
-        # Create a subgraph based on the specific edge length threshold for this algorithm
-        subgraph = _create_percentile_limited_subgraph(network, edge_length_percentile=threshold)
-        # Call the appropriate neighborhood function based on the metric
-        if metric == "louvain":
-            neighborhoods = calculate_louvain_neighborhoods(
-                subgraph, louvain_resolution, random_seed=random_seed
-            )
-        elif metric == "greedy_modularity":
+    for metric, threshold in zip(distance_metric, edge_rank_percentile):
+        # Create a subgraph based on the edge length threshold
+        subgraph = _create_percentile_limited_subgraph(network, edge_rank_percentile=threshold)
+        subgraph_nodes = list(subgraph.nodes)
+        # Calculate neighborhoods based on the specified metric
+        if metric == "greedy_modularity":
             neighborhoods = calculate_greedy_modularity_neighborhoods(subgraph)
         elif metric == "label_propagation":
             neighborhoods = calculate_label_propagation_neighborhoods(subgraph)
+        elif metric == "leiden":
+            neighborhoods = calculate_leiden_neighborhoods(
+                subgraph, leiden_resolution, random_seed=random_seed
+            )
+        elif metric == "louvain":
+            neighborhoods = calculate_louvain_neighborhoods(
+                subgraph, louvain_resolution, random_seed=random_seed
+            )
         elif metric == "markov_clustering":
             neighborhoods = calculate_markov_clustering_neighborhoods(subgraph)
-        elif metric == "walktrap":
-            neighborhoods = calculate_walktrap_neighborhoods(subgraph)
         elif metric == "spinglass":
             neighborhoods = calculate_spinglass_neighborhoods(subgraph)
+        elif metric == "walktrap":
+            neighborhoods = calculate_walktrap_neighborhoods(subgraph)
         else:
             raise ValueError(
-                "Incorrect distance metric specified. Please choose from 'greedy_modularity', 'louvain',"
-                "'label_propagation', 'markov_clustering', 'walktrap', 'spinglass'."
+                "Invalid distance metric specified. Please choose from 'greedy_modularity', 'label_propagation',"
+                "'leiden', 'louvain', 'markov_clustering', 'spinglass', 'walktrap'."
             )
 
-        # Sum the neighborhood matrices
-        combined_neighborhoods += neighborhoods
+        # Expand the neighborhood matrix to match the original network's size
+        expanded_neighborhoods = expand_neighborhood_matrix(
+            neighborhoods, subgraph_nodes, num_nodes
+        )
+        # Sum the expanded neighborhood matrices
+        combined_neighborhoods += expanded_neighborhoods
 
-    # Ensure that the maximum value in each row is set to 1
-    # This ensures that for each row, only the strongest relationship (the maximum value) is retained,
-    # while all other values are reset to 0. This transformation simplifies the neighborhood matrix by
-    # focusing on the most significant connection per row.
-    combined_neighborhoods = _set_max_to_one(combined_neighborhoods)
+    # Convert combined_neighborhoods to binary: values > 0 are set to 1
+    combined_neighborhoods = (combined_neighborhoods > 0).astype(int)
 
     return combined_neighborhoods
 
 
-def _create_percentile_limited_subgraph(G: nx.Graph, edge_length_percentile: float) -> nx.Graph:
-    """Create a subgraph containing all nodes and edges where the edge length is below the
-    specified percentile of all edge lengths in the input graph.
+def expand_neighborhood_matrix(
+    subgraph_matrix: np.ndarray, subgraph_nodes: list, original_size: int
+) -> np.ndarray:
+    """Expand a subgraph neighborhood matrix back to the size of the original graph.
 
     Args:
-        G (nx.Graph): The input graph with 'length' attributes on edges.
-        edge_length_percentile (float): The percentile (between 0 and 1) to filter edges by length.
+        subgraph_matrix (np.ndarray): The neighborhood matrix for the subgraph.
+        subgraph_nodes (list): List of nodes in the subgraph, corresponding to rows/columns in subgraph_matrix.
+        original_size (int): The number of nodes in the original graph.
 
     Returns:
-        nx.Graph: A subgraph with all nodes and edges where the edge length is below the
-        calculated threshold length.
+        np.ndarray: The expanded matrix with the original size, with subgraph values mapped correctly.
     """
-    # Extract edge lengths and handle missing lengths
-    edge_lengths = [d["length"] for _, _, d in G.edges(data=True) if "length" in d]
-    if not edge_lengths:
-        raise ValueError(
-            "No edge lengths found in the graph. Ensure edges have 'length' attributes."
-        )
+    expanded_matrix = np.zeros((original_size, original_size), dtype=int)
+    for i, node_i in enumerate(subgraph_nodes):
+        for j, node_j in enumerate(subgraph_nodes):
+            expanded_matrix[node_i, node_j] = subgraph_matrix[i, j]
+    return expanded_matrix
 
-    # Calculate the specific edge length for the given percentile
-    percentile_length = np.percentile(edge_lengths, edge_length_percentile * 100)
-    # Create the subgraph by directly filtering edges during iteration
-    subgraph = nx.Graph()
-    subgraph.add_nodes_from(G.nodes(data=True))  # Retain all nodes from the original graph
-    # Add edges below the specified percentile length in a single pass
-    for u, v, d in G.edges(data=True):
-        if d.get("length", 1) <= percentile_length:
-            subgraph.add_edge(u, v, **d)
 
-    # Return the subgraph; optionally check if it's too sparse
+def _create_percentile_limited_subgraph(G: nx.Graph, edge_rank_percentile: float) -> nx.Graph:
+    """Create a subgraph containing all nodes and edges where the edge length is within the
+    specified rank percentile of all edges in the input graph. Isolated nodes are removed.
+
+    Args:
+        G (nx.Graph): The input graph with 'length' attributes on edges.
+        edge_rank_percentile (float): The rank percentile (between 0 and 1) to filter edges.
+
+    Returns:
+        nx.Graph: A subgraph with nodes and edges where the edge length is within the
+        specified percentile, with isolated nodes removed, retaining all original attributes.
+    """
+    # Extract edges with their lengths
+    edges_with_length = [(u, v, d) for u, v, d in G.edges(data=True) if "length" in d]
+    if not edges_with_length:
+        raise ValueError("No edge lengths found. Ensure edges have 'length' attributes.")
+
+    # Sort edges by length in ascending order
+    edges_with_length.sort(key=lambda x: x[2]["length"])
+    # Calculate the cutoff based on the specified rank percentile
+    cutoff_index = int(edge_rank_percentile * len(edges_with_length))
+    if cutoff_index == 0:
+        raise ValueError("The rank percentile is too low, resulting in no edges being included.")
+
+    # Keep only the edges within the specified percentile
+    selected_edges = edges_with_length[:cutoff_index]
+    # Create a new subgraph with the selected edges, retaining all attributes
+    subgraph = nx.Graph()
+    subgraph.add_edges_from((u, v, d) for u, v, d in selected_edges)
+    # Copy over all node attributes from the original graph
+    subgraph.add_nodes_from((node, G.nodes[node]) for node in subgraph.nodes())
+
+    # Remove isolated nodes (if any)
+    isolated_nodes = [node for node, degree in subgraph.degree() if degree == 0]
+    subgraph.remove_nodes_from(isolated_nodes)
+    # Check if the resulting subgraph has no edges
     if subgraph.number_of_edges() == 0:
-        raise Warning("The resulting subgraph has no edges. Consider adjusting the percentile.")
+        raise ValueError("The resulting subgraph has no edges. Adjust the rank percentile.")
 
     return subgraph
 
 
-def _set_max_to_one(matrix: np.ndarray) -> np.ndarray:
-    """For each row in the input matrix, set the maximum value(s) to 1 and all other values to 0.
+def _set_max_row_value_to_one(matrix: np.ndarray) -> np.ndarray:
+    """For each row in the input matrix, set the maximum value(s) to 1 and all other values to 0. This is particularly
+    useful for neighborhood matrices that have undergone multiple neighborhood detection algorithms, where the
+    maximum value in each row represents the most significant relationship per node in the combined neighborhoods.
 
     Args:
         matrix (np.ndarray): A 2D numpy array representing the neighborhood matrix.

risk/network/plot/labels.py

@@ -617,8 +617,7 @@ class Labels:
         """
         # Return custom labels if domain is in ids_to_labels
         if ids_to_labels and domain in ids_to_labels:
-            terms = ids_to_labels[domain].replace(" ", TERM_DELIMITER)
-            return terms
+            return ids_to_labels[domain]
 
         else:
             terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")

risk/network/plot/utils/colors.py

@@ -234,88 +234,37 @@ def _get_colors(
     color: Union[str, List, Tuple, np.ndarray, None] = None,
     random_seed: int = 888,
 ) -> List[Tuple]:
-    """Generate a list of RGBA colors based on domain centroids, ensuring that domains
-    close in space get maximally separated colors, while keeping some randomness.
+    """Generate a list of RGBA colors for domains, ensuring maximally separated colors for nearby domains.
 
     Args:
         network (nx.Graph): The graph representing the network.
         domain_id_to_node_ids_map (Dict[int, Any]): Mapping from domain IDs to lists of node IDs.
         cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
-        color (str, List, Tuple, np.ndarray, or None, optional): A specific color or array of colors to use for the domains.
+        color (str, List, Tuple, np.ndarray, or None, optional): A specific color or array of colors to use.
             If None, the colormap will be used. Defaults to None.
         random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
     Returns:
-        List[Tuple]: List of RGBA colors.
+        List[Tuple]: List of RGBA colors for each domain.
     """
-    # Set random seed for reproducibility
     np.random.seed(random_seed)
-
-    # Determine the number of colors to generate based on the number of domains
     num_domains = len(domain_id_to_node_ids_map)
     if color:
-        # Generate all colors as the same specified color
+        # If a single color is specified, apply it to all domains
         rgba = to_rgba(color, num_repeats=num_domains)
         return rgba
 
-    # Load colormap
+    # Load colormap and generate a large, maximally separated set of colors
     colormap = matplotlib.colormaps.get_cmap(cmap)
-    # Step 1: Calculate centroids for each domain
-    centroids = calculate_centroids(network, domain_id_to_node_ids_map)
-    centroid_array = np.array(centroids)
-
-    # Step 2: Cluster domains based on proximity using Agglomerative Clustering
-    dist_matrix = np.linalg.norm(centroid_array[:, None] - centroid_array, axis=-1)
-    max_distance = np.max(dist_matrix) if np.max(dist_matrix) != 0 else 1
-    proximity_threshold = 0.3 * max_distance
-
-    clustering_model = AgglomerativeClustering(
-        n_clusters=None, distance_threshold=proximity_threshold
-    )
-    cluster_labels = clustering_model.fit_predict(centroid_array)
-    num_clusters = len(set(cluster_labels))
-
-    # Step 3: Assign base color positions for each cluster, spaced across colormap
-    cluster_positions = np.linspace(0, 1, num_clusters, endpoint=False)
-    np.random.shuffle(cluster_positions)  # Shuffle based on seed to vary color layout
-    cluster_id_to_position = {
-        cluster_id: pos for cluster_id, pos in zip(np.unique(cluster_labels), cluster_positions)
-    }
-
-    # Step 4: Assign colors to each domain based on cluster base color with a global shift
-    global_shift = np.random.uniform(-0.1, 0.1)  # Small global shift for variety
-    colors = []
-    for i in range(num_domains):
-        cluster_idx = cluster_labels[i]
-        base_position = cluster_id_to_position[cluster_idx]
-        # Add global shift and ensure it stays within [0, 1]
-        color_position = (base_position + global_shift) % 1
-        colors.append(colormap(color_position))  # Get color from colormap
+    color_positions = np.linspace(0, 1, num_domains, endpoint=False)
+    # Shuffle color positions to avoid spatial clustering of similar colors
+    np.random.shuffle(color_positions)
+    # Assign colors based on positions in the colormap
+    colors = [colormap(pos) for pos in color_positions]
 
     return colors
 
 
-def _assign_distant_colors(dist_matrix: np.ndarray, num_colors_to_generate: int) -> np.ndarray:
-    """Assign color positions ensuring centroids close in space are maximally separated in color.
-
-    Args:
-        dist_matrix (ndarray): Matrix of pairwise centroid distances.
-        num_colors_to_generate (int): Number of colors to generate.
-
-    Returns:
-        np.array: Array of color positions in the range [0, 1].
-    """
-    # Step 1: Calculate proximity order based on the sum of distances
-    proximity_order = sorted(
-        range(num_colors_to_generate), key=lambda idx: np.sum(dist_matrix[idx])
-    )
-    # Step 2: Generate evenly spaced color positions
-    color_positions = np.linspace(0, 1, num_colors_to_generate, endpoint=False)
-    # Step 3: Shuffle color positions based on proximity
-    color_positions = color_positions[proximity_order]
-    return color_positions
-
-
 def _blend_colors_perceptually(
     colors: Union[List, Tuple, np.ndarray], significances: List[float], gamma: float = 2.2
 ) -> Tuple[float, float, float, float]:

risk/risk.py

@@ -52,7 +52,8 @@ class RISK(NetworkIO, AnnotationsIO):
         annotations: Dict[str, Any],
         distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
+        leiden_resolution: float = 1.0,
+        edge_rank_percentile: Union[float, List, Tuple, np.ndarray] = 0.5,
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
@@ -65,7 +66,8 @@ class RISK(NetworkIO, AnnotationsIO):
                 metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
                 'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
+            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
+            edge_rank_percentile (float, List, Tuple, or np.ndarray, optional): Shortest edge rank percentile threshold(s) for creating subgraphs.
                 Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
                 Defaults to 0.5.
             null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
@@ -79,7 +81,8 @@ class RISK(NetworkIO, AnnotationsIO):
         params.log_neighborhoods(
             distance_metric=distance_metric,
             louvain_resolution=louvain_resolution,
-            edge_length_threshold=edge_length_threshold,
+            leiden_resolution=leiden_resolution,
+            edge_rank_percentile=edge_rank_percentile,
             statistical_test_function="hypergeom",
             null_distribution=null_distribution,
             random_seed=random_seed,
@@ -93,7 +96,8 @@ class RISK(NetworkIO, AnnotationsIO):
             network,
             distance_metric,
             louvain_resolution=louvain_resolution,
-            edge_length_threshold=edge_length_threshold,
+            leiden_resolution=leiden_resolution,
+            edge_rank_percentile=edge_rank_percentile,
             random_seed=random_seed,
         )
         # Run hypergeometric test to compute neighborhood significance
@@ -112,7 +116,8 @@ class RISK(NetworkIO, AnnotationsIO):
         annotations: Dict[str, Any],
         distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
+        leiden_resolution: float = 1.0,
+        edge_rank_percentile: Union[float, List, Tuple, np.ndarray] = 0.5,
         null_distribution: str = "network",
         random_seed: int = 888,
     ) -> Dict[str, Any]:
@@ -125,7 +130,8 @@ class RISK(NetworkIO, AnnotationsIO):
                 metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
                 'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
+            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
+            edge_rank_percentile (float, List, Tuple, or np.ndarray, optional): Shortest edge rank percentile threshold(s) for creating subgraphs.
                 Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
                 Defaults to 0.5.
             null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
@@ -139,7 +145,8 @@ class RISK(NetworkIO, AnnotationsIO):
         params.log_neighborhoods(
             distance_metric=distance_metric,
             louvain_resolution=louvain_resolution,
-            edge_length_threshold=edge_length_threshold,
+            leiden_resolution=leiden_resolution,
+            edge_rank_percentile=edge_rank_percentile,
             statistical_test_function="poisson",
             null_distribution=null_distribution,
             random_seed=random_seed,
@@ -153,7 +160,8 @@ class RISK(NetworkIO, AnnotationsIO):
             network,
             distance_metric,
             louvain_resolution=louvain_resolution,
-            edge_length_threshold=edge_length_threshold,
+            leiden_resolution=leiden_resolution,
+            edge_rank_percentile=edge_rank_percentile,
             random_seed=random_seed,
         )
         # Run Poisson test to compute neighborhood significance
@@ -172,7 +180,8 @@ class RISK(NetworkIO, AnnotationsIO):
         annotations: Dict[str, Any],
         distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
+        leiden_resolution: float = 1.0,
+        edge_rank_percentile: Union[float, List, Tuple, np.ndarray] = 0.5,
         score_metric: str = "sum",
         null_distribution: str = "network",
         num_permutations: int = 1000,
@@ -188,7 +197,8 @@ class RISK(NetworkIO, AnnotationsIO):
                 metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
                 'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
+            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
+            edge_rank_percentile (float, List, Tuple, or np.ndarray, optional): Shortest edge rank percentile threshold(s) for creating subgraphs.
                 Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
                 Defaults to 0.5.
             score_metric (str, optional): Scoring metric for neighborhood significance. Defaults to "sum".
@@ -205,7 +215,8 @@ class RISK(NetworkIO, AnnotationsIO):
         params.log_neighborhoods(
             distance_metric=distance_metric,
             louvain_resolution=louvain_resolution,
-            edge_length_threshold=edge_length_threshold,
+            leiden_resolution=leiden_resolution,
+            edge_rank_percentile=edge_rank_percentile,
             statistical_test_function="permutation",
             score_metric=score_metric,
             null_distribution=null_distribution,
@@ -222,7 +233,8 @@ class RISK(NetworkIO, AnnotationsIO):
             network,
             distance_metric,
             louvain_resolution=louvain_resolution,
-            edge_length_threshold=edge_length_threshold,
+            leiden_resolution=leiden_resolution,
+            edge_rank_percentile=edge_rank_percentile,
             random_seed=random_seed,
         )
 
@@ -408,7 +420,8 @@ class RISK(NetworkIO, AnnotationsIO):
         network: nx.Graph,
         distance_metric: Union[str, List, Tuple, np.ndarray] = "louvain",
         louvain_resolution: float = 0.1,
-        edge_length_threshold: Union[float, List, Tuple, np.ndarray] = 0.5,
+        leiden_resolution: float = 1.0,
+        edge_rank_percentile: Union[float, List, Tuple, np.ndarray] = 0.5,
         random_seed: int = 888,
     ) -> np.ndarray:
         """Load significant neighborhoods for the network.
@@ -420,7 +433,8 @@ class RISK(NetworkIO, AnnotationsIO):
                 metric or a list/tuple/ndarray of metrics ('greedy_modularity', 'louvain', 'label_propagation',
                 'markov_clustering', 'walktrap', 'spinglass'). Defaults to 'louvain'.
             louvain_resolution (float, optional): Resolution parameter for Louvain clustering. Defaults to 0.1.
-            edge_length_threshold (float, List, Tuple, or np.ndarray, optional): Edge length threshold(s) for creating subgraphs.
+            leiden_resolution (float, optional): Resolution parameter for Leiden clustering. Defaults to 1.0.
+            edge_rank_percentile (float, List, Tuple, or np.ndarray, optional): Shortest edge rank percentile threshold(s) for creating subgraphs.
                 Can be a single float for one threshold or a list/tuple of floats corresponding to multiple thresholds.
                 Defaults to 0.5.
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
@@ -431,19 +445,22 @@ class RISK(NetworkIO, AnnotationsIO):
         # Display the chosen distance metric
         if distance_metric == "louvain":
             for_print_distance_metric = f"louvain (resolution={louvain_resolution})"
+        elif distance_metric == "leiden":
+            for_print_distance_metric = f"leiden (resolution={leiden_resolution})"
         else:
             for_print_distance_metric = distance_metric
         # Log and display neighborhood settings
         logger.debug(f"Distance metric: '{for_print_distance_metric}'")
-        logger.debug(f"Edge length threshold: {edge_length_threshold}")
+        logger.debug(f"Edge length threshold: {edge_rank_percentile}")
         logger.debug(f"Random seed: {random_seed}")
 
         # Compute neighborhoods based on the network and distance metric
         neighborhoods = get_network_neighborhoods(
             network,
             distance_metric,
-            edge_length_threshold,
+            edge_rank_percentile,
             louvain_resolution=louvain_resolution,
+            leiden_resolution=leiden_resolution,
             random_seed=random_seed,
         )
 

{risk_network-0.0.9b8.dist-info → risk_network-0.0.9b11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.9b8
+Version: 0.0.9b11
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>
@@ -695,6 +695,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ipywidgets
+Requires-Dist: leidenalg
 Requires-Dist: markov-clustering
 Requires-Dist: matplotlib
 Requires-Dist: networkx
@@ -702,6 +703,7 @@ Requires-Dist: nltk==3.8.1
 Requires-Dist: numpy
 Requires-Dist: openpyxl
 Requires-Dist: pandas
+Requires-Dist: python-igraph
 Requires-Dist: python-louvain
 Requires-Dist: scikit-learn
 Requires-Dist: scipy

{risk_network-0.0.9b8.dist-info → risk_network-0.0.9b11.dist-info}/RECORD

@@ -1,6 +1,6 @@
-risk/__init__.py,sha256=CF_5U_LFsoHtqjLJO9F0HRUYI0sDt4UlIWwkpkOG-no,112
+risk/__init__.py,sha256=lx2px2aUNVzyhWttIeSRddS0TyVt5tkNaoDp26k1OmE,113
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
-risk/risk.py,sha256=kntBxYwAEpoAjXN_l6BM3yxFKyuAKmd8OMGl2P00pZ4,22416
+risk/risk.py,sha256=MXu8T93NUgMDl3NaZDbm0j9c4KWwzx-kmp9Rd1ax0N4,23534
 risk/annotations/__init__.py,sha256=kXgadEXaCh0z8OyhOhTj7c3qXGmWgOhaSZ4gSzSb59U,147
 risk/annotations/annotations.py,sha256=WVT9wzTm8lTpMw_3SnbyljWR77yExo0rb1zVgJza8nw,14284
 risk/annotations/io.py,sha256=tk1dAsxIwW5oLxB294ppiuZd4__Y5pj8se8KhitRSNA,10554
@@ -8,9 +8,9 @@ risk/log/__init__.py,sha256=gy7C5L6D222AYUChq5lkc0LsCJ_QMQPaFiBJKbecdac,201
 risk/log/console.py,sha256=C52s3FgQ2e9kQWcXL8m7rs_pnKXt5Yy8PBHmQkOTiNo,4537
 risk/log/parameters.py,sha256=o4StqYCa0kt7_Ht4mKa1DwwvhGUwkC_dGBaiUIc0GB0,5683
 risk/neighborhoods/__init__.py,sha256=C-SD0G-9skSLjLFdAB6v6lAjO8la2v6Fqy63h2MY28k,186
-risk/neighborhoods/community.py,sha256=MAgIblbuisEPwVU6mFZd4Yd9NUKlaHK99suw51r1Is0,7065
+risk/neighborhoods/community.py,sha256=z8oZGBUZLriYBbT4-0uKDn8iM8SmN5dubrHb7zxcn4w,10431
 risk/neighborhoods/domains.py,sha256=t91xSpx9Ty9hSlhRq2_XwyPpBP7sjKhovcPPvkwWtf0,11398
-risk/neighborhoods/neighborhoods.py,sha256=0TAP-xi4hgtnrK0cKQPHQHq9IVGHOMF1wYEcx6tsxRA,22241
+risk/neighborhoods/neighborhoods.py,sha256=D-t1v6EcmKn6B8uZK5X5tU9uOV0OfkKzvETGfZWRnic,23561
 risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
 risk/network/geometry.py,sha256=gFtYUj9j9aul4paKq_qSGJn39Nazxu_MXv8m-tYYtrk,6840
 risk/network/io.py,sha256=AWSbZGLZHtl72KSlafQlcYoG00YLSznG7UYDi_wDT7M,22958
@@ -20,10 +20,10 @@ risk/network/graph/summary.py,sha256=h2bpUjfwI1NMflkKwplGQEGPswfAtunormdTIEQYbvs
 risk/network/plot/__init__.py,sha256=MfmaXJgAZJgXZ2wrhK8pXwzETlcMaLChhWXKAozniAo,98
 risk/network/plot/canvas.py,sha256=W8dFv4XYTzCWXBchgsc0esOQRn4usM4LkwNGPSDMobE,13357
 risk/network/plot/contour.py,sha256=VONX9l6owrZvWtR0mWQ6z2GSd1YXIv5wV_sf5ROQLT4,15581
-risk/network/plot/labels.py,sha256=eorP80CmAbHmt7de2qHna1tHGKL8YiHknwFW2R3tvjI,45734
+risk/network/plot/labels.py,sha256=aU_ClDGVPHyQ3H5E_ygx8hsMhrpJB0i9Cn65PlLmw7s,45679
 risk/network/plot/network.py,sha256=_K8Am2y6zSGrm3fAgMbXxzgspbugJi3uK4_tG8qqGoI,14015
 risk/network/plot/plotter.py,sha256=eS1vHqvOA2O001Rq7WiDcgqcehJ3fg4OPfvkezH4erw,5771
-risk/network/plot/utils/colors.py,sha256=lNDwlTbpXCKAbaqSHsRlxxY_MRAbogma81xyqHawl3U,21005
+risk/network/plot/utils/colors.py,sha256=9zuU2O-Nkpljb1yVGUR_IjqD1y-wH6Bf6Vm1MMVB0Lo,18718
 risk/network/plot/utils/layout.py,sha256=6o7idoWQnyzujSWOFXQykUvyPy8NuRtJV04TnlbXXBo,3647
 risk/stats/__init__.py,sha256=WcgoETQ-hS0LQqKRsAMIPtP15xZ-4eul6VUBuUx4Wzc,220
 risk/stats/hypergeom.py,sha256=oc39f02ViB1vQ-uaDrxG_tzAT6dxQBRjc88EK2EGn78,2282
@@ -32,8 +32,8 @@ risk/stats/stats.py,sha256=z8NrhiVj4BzJ250bVLfytpmfC7RzYu7mBuIZD_l0aCA,7222
 risk/stats/permutation/__init__.py,sha256=neJp7FENC-zg_CGOXqv-iIvz1r5XUKI9Ruxhmq7kDOI,105
 risk/stats/permutation/permutation.py,sha256=meBNSrbRa9P8WJ54n485l0H7VQJlMSfHqdN4aCKYCtQ,10105
 risk/stats/permutation/test_functions.py,sha256=lftOude6hee0pyR80HlBD32522JkDoN5hrKQ9VEbuoY,2345
-risk_network-0.0.9b8.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.9b8.dist-info/METADATA,sha256=JaTFHNn11mwliUNgsG6jvz2sU53goxjS3cwQXLEbcEw,47497
-risk_network-0.0.9b8.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-risk_network-0.0.9b8.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.9b8.dist-info/RECORD,,
+risk_network-0.0.9b11.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.9b11.dist-info/METADATA,sha256=38pUWpqTrjTbc5LQ1_JnRqOpXwgSS-J1wVHHBMTTQ6M,47552
+risk_network-0.0.9b11.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+risk_network-0.0.9b11.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.9b11.dist-info/RECORD,,