risk-network 0.0.7b11__py3-none-any.whl → 0.0.8__py3-none-any.whl

risk/neighborhoods/neighborhoods.py

@@ -5,7 +5,7 @@ risk/neighborhoods/neighborhoods
 
 import random
 import warnings
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Tuple, Union
 
 import networkx as nx
 import numpy as np
@@ -28,50 +28,82 @@ warnings.filterwarnings(action="ignore", category=DataConversionWarning)
 
 def get_network_neighborhoods(
     network: nx.Graph,
-    distance_metric: str = "louvain",
-    edge_length_threshold: float = 1.0,
+    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,
     random_seed: int = 888,
 ) -> np.ndarray:
-    """Calculate the neighborhoods for each node in the network based on the specified distance metric.
+    """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): The distance metric to use ('greedy_modularity', 'louvain', 'label_propagation',
-            'markov_clustering', 'walktrap', 'spinglass').
-        edge_length_threshold (float): The edge length threshold for the neighborhoods.
+        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.
 
     Returns:
-        np.ndarray: Neighborhood matrix calculated based on the selected distance metric.
+        np.ndarray: Summed neighborhood matrix from all selected algorithms.
     """
-    # Set random seed for reproducibility in all methods besides Louvain, which requires a separate seed
+    # Set random seed for reproducibility
     random.seed(random_seed)
     np.random.seed(random_seed)
 
-    # Create a subgraph based on the edge length percentile threshold
-    network = _create_percentile_limited_subgraph(
-        network, edge_length_percentile=edge_length_threshold
-    )
+    # Ensure distance_metric is a list/tuple for multi-algorithm handling
+    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):
+        raise ValueError(
+            "The number of distance metrics must match the number of edge length thresholds."
+        )
 
-    if distance_metric == "louvain":
-        return calculate_louvain_neighborhoods(network, louvain_resolution, random_seed=random_seed)
-    if distance_metric == "greedy_modularity":
-        return calculate_greedy_modularity_neighborhoods(network)
-    if distance_metric == "label_propagation":
-        return calculate_label_propagation_neighborhoods(network)
-    if distance_metric == "markov_clustering":
-        return calculate_markov_clustering_neighborhoods(network)
-    if distance_metric == "walktrap":
-        return calculate_walktrap_neighborhoods(network)
-    if distance_metric == "spinglass":
-        return calculate_spinglass_neighborhoods(network)
-
-    raise ValueError(
-        "Incorrect distance metric specified. Please choose from 'greedy_modularity', 'louvain',"
-        "'label_propagation', 'markov_clustering', 'walktrap', 'spinglass'."
-    )
+    # Initialize combined neighborhood matrix
+    num_nodes = network.number_of_nodes()
+    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":
+            neighborhoods = calculate_greedy_modularity_neighborhoods(subgraph)
+        elif metric == "label_propagation":
+            neighborhoods = calculate_label_propagation_neighborhoods(subgraph)
+        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)
+        else:
+            raise ValueError(
+                "Incorrect distance metric specified. Please choose from 'greedy_modularity', 'louvain',"
+                "'label_propagation', 'markov_clustering', 'walktrap', 'spinglass'."
+            )
+
+        # Sum the neighborhood matrices
+        combined_neighborhoods += 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)
+
+    return combined_neighborhoods
 
 
 def _create_percentile_limited_subgraph(G: nx.Graph, edge_length_percentile: float) -> nx.Graph:
@@ -110,6 +142,25 @@ def _create_percentile_limited_subgraph(G: nx.Graph, edge_length_percentile: flo
     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.
+
+    Args:
+        matrix (np.ndarray): A 2D numpy array representing the neighborhood matrix.
+
+    Returns:
+        np.ndarray: The modified matrix where only the maximum value(s) in each row is set to 1, and others are set to 0.
+    """
+    # Find the maximum value in each row (column-wise max operation)
+    max_values = np.max(matrix, axis=1, keepdims=True)
+    # Create a boolean mask where elements are True if they are the max value in their row
+    max_mask = matrix == max_values
+    # Set all elements to 0, and then set the maximum value positions to 1
+    matrix[:] = 0  # Set everything to 0
+    matrix[max_mask] = 1  # Set only the max values to 1
+    return matrix
+
+
 def process_neighborhoods(
     network: nx.Graph,
     neighborhoods: Dict[str, Any],
@@ -120,47 +171,47 @@ def process_neighborhoods(
 
     Args:
         network (nx.Graph): The network data structure used for imputing and pruning neighbors.
-        neighborhoods (dict): Dictionary containing 'enrichment_matrix', 'binary_enrichment_matrix', and 'significant_enrichment_matrix'.
+        neighborhoods (Dict[str, Any]): Dictionary containing 'enrichment_matrix', 'significant_binary_enrichment_matrix', and 'significant_enrichment_matrix'.
         impute_depth (int, optional): Depth for imputing neighbors. Defaults to 0.
         prune_threshold (float, optional): Distance threshold for pruning neighbors. Defaults to 0.0.
 
     Returns:
-        dict: Processed neighborhoods data, including the updated matrices and enrichment counts.
+        Dict[str, Any]: Processed neighborhoods data, including the updated matrices and enrichment counts.
     """
     enrichment_matrix = neighborhoods["enrichment_matrix"]
-    binary_enrichment_matrix = neighborhoods["binary_enrichment_matrix"]
+    significant_binary_enrichment_matrix = neighborhoods["significant_binary_enrichment_matrix"]
     significant_enrichment_matrix = neighborhoods["significant_enrichment_matrix"]
-    logger.info(f"Imputation depth: {impute_depth}")
+    logger.debug(f"Imputation depth: {impute_depth}")
     if impute_depth:
         (
             enrichment_matrix,
-            binary_enrichment_matrix,
+            significant_binary_enrichment_matrix,
             significant_enrichment_matrix,
         ) = _impute_neighbors(
             network,
             enrichment_matrix,
-            binary_enrichment_matrix,
+            significant_binary_enrichment_matrix,
             max_depth=impute_depth,
         )
 
-    logger.info(f"Pruning threshold: {prune_threshold}")
+    logger.debug(f"Pruning threshold: {prune_threshold}")
     if prune_threshold:
         (
             enrichment_matrix,
-            binary_enrichment_matrix,
+            significant_binary_enrichment_matrix,
             significant_enrichment_matrix,
         ) = _prune_neighbors(
             network,
             enrichment_matrix,
-            binary_enrichment_matrix,
+            significant_binary_enrichment_matrix,
             distance_threshold=prune_threshold,
         )
 
-    neighborhood_enrichment_counts = np.sum(binary_enrichment_matrix, axis=0)
+    neighborhood_enrichment_counts = np.sum(significant_binary_enrichment_matrix, axis=0)
     node_enrichment_sums = np.sum(enrichment_matrix, axis=1)
     return {
         "enrichment_matrix": enrichment_matrix,
-        "binary_enrichment_matrix": binary_enrichment_matrix,
+        "significant_binary_enrichment_matrix": significant_binary_enrichment_matrix,
         "significant_enrichment_matrix": significant_enrichment_matrix,
         "neighborhood_enrichment_counts": neighborhood_enrichment_counts,
         "node_enrichment_sums": node_enrichment_sums,
@@ -170,7 +221,7 @@ def process_neighborhoods(
 def _impute_neighbors(
     network: nx.Graph,
     enrichment_matrix: np.ndarray,
-    binary_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     max_depth: int = 3,
 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Impute rows with sums of zero in the enrichment matrix based on the closest non-zero neighbors in the network graph.
@@ -178,7 +229,7 @@ def _impute_neighbors(
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
         enrichment_matrix (np.ndarray): The enrichment matrix with rows to be imputed.
-        binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         max_depth (int): Maximum depth of nodes to traverse for imputing values.
 
     Returns:
@@ -188,19 +239,21 @@ def _impute_neighbors(
             - np.ndarray: The significant enrichment matrix with non-significant entries set to zero.
     """
     # Calculate the distance threshold value based on the shortest distances
-    enrichment_matrix, binary_enrichment_matrix = _impute_neighbors_with_similarity(
-        network, enrichment_matrix, binary_enrichment_matrix, max_depth=max_depth
+    enrichment_matrix, significant_binary_enrichment_matrix = _impute_neighbors_with_similarity(
+        network, enrichment_matrix, significant_binary_enrichment_matrix, max_depth=max_depth
     )
     # Create a matrix where non-significant entries are set to zero
-    significant_enrichment_matrix = np.where(binary_enrichment_matrix == 1, enrichment_matrix, 0)
+    significant_enrichment_matrix = np.where(
+        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    )
 
-    return enrichment_matrix, binary_enrichment_matrix, significant_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix, significant_enrichment_matrix
 
 
 def _impute_neighbors_with_similarity(
     network: nx.Graph,
     enrichment_matrix: np.ndarray,
-    binary_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     max_depth: int = 3,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """Impute non-enriched nodes based on the closest enriched neighbors' profiles and their similarity.
@@ -208,7 +261,7 @@ def _impute_neighbors_with_similarity(
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
         enrichment_matrix (np.ndarray): The enrichment matrix with rows to be imputed.
-        binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         max_depth (int): Maximum depth of nodes to traverse for imputing values.
 
     Returns:
@@ -217,27 +270,31 @@ def _impute_neighbors_with_similarity(
             - The imputed alpha threshold matrix.
     """
     depth = 1
-    rows_to_impute = np.where(binary_enrichment_matrix.sum(axis=1) == 0)[0]
+    rows_to_impute = np.where(significant_binary_enrichment_matrix.sum(axis=1) == 0)[0]
     while len(rows_to_impute) and depth <= max_depth:
         # Iterate over all enriched nodes
-        for row_index in range(binary_enrichment_matrix.shape[0]):
-            if binary_enrichment_matrix[row_index].sum() != 0:
-                enrichment_matrix, binary_enrichment_matrix = _process_node_imputation(
-                    row_index, network, enrichment_matrix, binary_enrichment_matrix, depth
+        for row_index in range(significant_binary_enrichment_matrix.shape[0]):
+            if significant_binary_enrichment_matrix[row_index].sum() != 0:
+                enrichment_matrix, significant_binary_enrichment_matrix = _process_node_imputation(
+                    row_index,
+                    network,
+                    enrichment_matrix,
+                    significant_binary_enrichment_matrix,
+                    depth,
                 )
 
         # Update rows to impute for the next iteration
-        rows_to_impute = np.where(binary_enrichment_matrix.sum(axis=1) == 0)[0]
+        rows_to_impute = np.where(significant_binary_enrichment_matrix.sum(axis=1) == 0)[0]
         depth += 1
 
-    return enrichment_matrix, binary_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix
 
 
 def _process_node_imputation(
     row_index: int,
     network: nx.Graph,
     enrichment_matrix: np.ndarray,
-    binary_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     depth: int,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """Process the imputation for a single node based on its enriched neighbors.
@@ -246,7 +303,7 @@ def _process_node_imputation(
         row_index (int): The index of the enriched node being processed.
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
         enrichment_matrix (np.ndarray): The enrichment matrix with rows to be imputed.
-        binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         depth (int): Current depth for traversal.
 
     Returns:
@@ -259,7 +316,7 @@ def _process_node_imputation(
         n
         for n in neighbors
         if n != row_index
-        and binary_enrichment_matrix[n].sum() != 0
+        and significant_binary_enrichment_matrix[n].sum() != 0
         and enrichment_matrix[n].sum() != 0
     ]
     # Filter non-enriched neighbors
@@ -267,7 +324,7 @@ def _process_node_imputation(
         n
         for n in neighbors
         if n != row_index
-        and binary_enrichment_matrix[n].sum() == 0
+        and significant_binary_enrichment_matrix[n].sum() == 0
         and enrichment_matrix[n].sum() == 0
     ]
     # If there are valid non-enriched neighbors
@@ -312,15 +369,17 @@ def _process_node_imputation(
             enrichment_matrix[most_similar_neighbor] = enrichment_matrix[row_index] / np.sqrt(
                 depth + 1
             )
-            binary_enrichment_matrix[most_similar_neighbor] = binary_enrichment_matrix[row_index]
+            significant_binary_enrichment_matrix[most_similar_neighbor] = (
+                significant_binary_enrichment_matrix[row_index]
+            )
 
-    return enrichment_matrix, binary_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix
 
 
 def _prune_neighbors(
     network: nx.Graph,
     enrichment_matrix: np.ndarray,
-    binary_enrichment_matrix: np.ndarray,
+    significant_binary_enrichment_matrix: np.ndarray,
     distance_threshold: float = 0.9,
 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Remove outliers based on their rank for edge lengths.
@@ -328,7 +387,7 @@ def _prune_neighbors(
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
         enrichment_matrix (np.ndarray): The enrichment matrix.
-        binary_enrichment_matrix (np.ndarray): The alpha threshold matrix.
+        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix.
         distance_threshold (float): Rank threshold (0 to 1) to determine outliers.
 
     Returns:
@@ -338,10 +397,12 @@ def _prune_neighbors(
             - np.ndarray: The significant enrichment matrix, where non-significant entries are set to zero.
     """
     # Identify indices with non-zero rows in the binary enrichment matrix
-    non_zero_indices = np.where(binary_enrichment_matrix.sum(axis=1) != 0)[0]
+    non_zero_indices = np.where(significant_binary_enrichment_matrix.sum(axis=1) != 0)[0]
     median_distances = []
     for node in non_zero_indices:
-        neighbors = [n for n in network.neighbors(node) if binary_enrichment_matrix[n].sum() != 0]
+        neighbors = [
+            n for n in network.neighbors(node) if significant_binary_enrichment_matrix[n].sum() != 0
+        ]
         if neighbors:
             median_distance = np.median(
                 [_get_euclidean_distance(node, n, network) for n in neighbors]
@@ -353,7 +414,9 @@ def _prune_neighbors(
     # Prune nodes that are outliers based on the distance threshold
     for row_index in non_zero_indices:
         neighbors = [
-            n for n in network.neighbors(row_index) if binary_enrichment_matrix[n].sum() != 0
+            n
+            for n in network.neighbors(row_index)
+            if significant_binary_enrichment_matrix[n].sum() != 0
         ]
         if neighbors:
             median_distance = np.median(
@@ -361,12 +424,14 @@ def _prune_neighbors(
             )
             if median_distance >= distance_threshold_value:
                 enrichment_matrix[row_index] = 0
-                binary_enrichment_matrix[row_index] = 0
+                significant_binary_enrichment_matrix[row_index] = 0
 
     # Create a matrix where non-significant entries are set to zero
-    significant_enrichment_matrix = np.where(binary_enrichment_matrix == 1, enrichment_matrix, 0)
+    significant_enrichment_matrix = np.where(
+        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    )
 
-    return enrichment_matrix, binary_enrichment_matrix, significant_enrichment_matrix
+    return enrichment_matrix, significant_binary_enrichment_matrix, significant_enrichment_matrix
 
 
 def _get_euclidean_distance(node1: Any, node2: Any, network: nx.Graph) -> float:
@@ -408,7 +473,7 @@ def _calculate_threshold(median_distances: List, distance_threshold: float) -> f
     """Calculate the distance threshold based on the given median distances and a percentile threshold.
 
     Args:
-        median_distances (list): An array of median distances.
+        median_distances (List): An array of median distances.
         distance_threshold (float): A percentile threshold (0 to 1) used to determine the distance cutoff.
 
     Returns:

risk/network/geometry.py

@@ -3,6 +3,8 @@ risk/network/geometry
 ~~~~~~~~~~~~~~~~~~~~~
 """
 
+import copy
+
 import networkx as nx
 import numpy as np
 
@@ -55,10 +57,10 @@ def assign_edge_lengths(
     if compute_sphere:
         # Map to sphere and adjust depth
         _map_to_sphere(G)
-        G_depth = _create_depth(G.copy(), surface_depth=surface_depth)
+        G_depth = _create_depth(copy.deepcopy(G), surface_depth=surface_depth)
     else:
         # Calculate edge lengths directly on the plane
-        G_depth = G.copy()
+        G_depth = copy.deepcopy(G)
 
     for u, v, _ in G_depth.edges(data=True):
         u_coords = np.array([G_depth.nodes[u]["x"], G_depth.nodes[u]["y"]])
@@ -68,6 +70,7 @@ def assign_edge_lengths(
             v_coords = np.append(v_coords, G_depth.nodes[v].get("z", 0))
 
         distance = compute_distance(u_coords, v_coords, is_sphere=compute_sphere)
+        # Assign edge lengths to the original graph
         if include_edge_weight:
             # Square root of the normalized weight is used to minimize the effect of large weights
             G.edges[u, v]["length"] = distance / np.sqrt(G.edges[u, v]["normalized_weight"] + 1e-6)