risk-network 0.0.8b27__py3-none-any.whl → 0.0.9b1__py3-none-any.whl

risk/__init__.py

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

risk/annotations/annotations.py

@@ -83,69 +83,69 @@ def load_annotations(network: nx.Graph, annotations_input: Dict[str, Any]) -> Di
 def define_top_annotations(
     network: nx.Graph,
     ordered_annotation_labels: List[str],
-    neighborhood_enrichment_sums: List[int],
-    significant_enrichment_matrix: np.ndarray,
-    significant_binary_enrichment_matrix: np.ndarray,
+    neighborhood_significance_sums: List[int],
+    significant_significance_matrix: np.ndarray,
+    significant_binary_significance_matrix: np.ndarray,
     min_cluster_size: int = 5,
     max_cluster_size: int = 1000,
 ) -> pd.DataFrame:
-    """Define top annotations based on neighborhood enrichment sums and binary enrichment matrix.
+    """Define top annotations based on neighborhood significance sums and binary significance matrix.
 
     Args:
         network (NetworkX graph): The network graph.
         ordered_annotation_labels (list of str): List of ordered annotation labels.
-        neighborhood_enrichment_sums (list of int): List of neighborhood enrichment sums.
-        significant_enrichment_matrix (np.ndarray): Enrichment matrix below alpha threshold.
-        significant_binary_enrichment_matrix (np.ndarray): Binary enrichment matrix below alpha threshold.
+        neighborhood_significance_sums (list of int): List of neighborhood significance sums.
+        significant_significance_matrix (np.ndarray): Enrichment matrix below alpha threshold.
+        significant_binary_significance_matrix (np.ndarray): Binary significance matrix below alpha threshold.
         min_cluster_size (int, optional): Minimum cluster size. Defaults to 5.
         max_cluster_size (int, optional): Maximum cluster size. Defaults to 1000.
 
     Returns:
         pd.DataFrame: DataFrame with top annotations and their properties.
     """
-    # Sum the columns of the significant enrichment matrix (positive floating point values)
-    significant_enrichment_scores = significant_enrichment_matrix.sum(axis=0)
-    # Create DataFrame to store annotations, their neighborhood enrichment sums, and enrichment scores
-    annotations_enrichment_matrix = pd.DataFrame(
+    # Sum the columns of the significant significance matrix (positive floating point values)
+    significant_significance_scores = significant_significance_matrix.sum(axis=0)
+    # Create DataFrame to store annotations, their neighborhood significance sums, and significance scores
+    annotations_significance_matrix = pd.DataFrame(
         {
             "id": range(len(ordered_annotation_labels)),
             "full_terms": ordered_annotation_labels,
-            "significant_neighborhood_enrichment_sums": neighborhood_enrichment_sums,
-            "significant_enrichment_score": significant_enrichment_scores,
+            "significant_neighborhood_significance_sums": neighborhood_significance_sums,
+            "significant_significance_score": significant_significance_scores,
         }
     )
-    annotations_enrichment_matrix["significant_annotations"] = False
+    annotations_significance_matrix["significant_annotations"] = False
     # Apply size constraints to identify potential significant annotations
-    annotations_enrichment_matrix.loc[
+    annotations_significance_matrix.loc[
         (
-            annotations_enrichment_matrix["significant_neighborhood_enrichment_sums"]
+            annotations_significance_matrix["significant_neighborhood_significance_sums"]
             >= min_cluster_size
         )
         & (
-            annotations_enrichment_matrix["significant_neighborhood_enrichment_sums"]
+            annotations_significance_matrix["significant_neighborhood_significance_sums"]
             <= max_cluster_size
         ),
         "significant_annotations",
     ] = True
     # Initialize columns for connected components analysis
-    annotations_enrichment_matrix["num_connected_components"] = 0
-    annotations_enrichment_matrix["size_connected_components"] = None
-    annotations_enrichment_matrix["size_connected_components"] = annotations_enrichment_matrix[
+    annotations_significance_matrix["num_connected_components"] = 0
+    annotations_significance_matrix["size_connected_components"] = None
+    annotations_significance_matrix["size_connected_components"] = annotations_significance_matrix[
         "size_connected_components"
     ].astype(object)
-    annotations_enrichment_matrix["num_large_connected_components"] = 0
+    annotations_significance_matrix["num_large_connected_components"] = 0
 
-    for attribute in annotations_enrichment_matrix.index.values[
-        annotations_enrichment_matrix["significant_annotations"]
+    for attribute in annotations_significance_matrix.index.values[
+        annotations_significance_matrix["significant_annotations"]
     ]:
-        # Identify enriched neighborhoods based on the binary enrichment matrix
-        enriched_neighborhoods = list(
-            compress(list(network), significant_binary_enrichment_matrix[:, attribute])
+        # Identify significant neighborhoods based on the binary significance matrix
+        significant_neighborhoods = list(
+            compress(list(network), significant_binary_significance_matrix[:, attribute])
         )
-        enriched_network = nx.subgraph(network, enriched_neighborhoods)
-        # Analyze connected components within the enriched subnetwork
+        significant_network = nx.subgraph(network, significant_neighborhoods)
+        # Analyze connected components within the significant subnetwork
         connected_components = sorted(
-            nx.connected_components(enriched_network), key=len, reverse=True
+            nx.connected_components(significant_network), key=len, reverse=True
         )
         size_connected_components = np.array([len(c) for c in connected_components])
 
@@ -159,23 +159,24 @@ def define_top_annotations(
         num_large_connected_components = len(filtered_size_connected_components)
 
         # Assign the number of connected components
-        annotations_enrichment_matrix.loc[attribute, "num_connected_components"] = (
+        annotations_significance_matrix.loc[attribute, "num_connected_components"] = (
             num_connected_components
         )
         # Filter out attributes with more than one connected component
-        annotations_enrichment_matrix.loc[
-            annotations_enrichment_matrix["num_connected_components"] > 1, "significant_annotations"
+        annotations_significance_matrix.loc[
+            annotations_significance_matrix["num_connected_components"] > 1,
+            "significant_annotations",
         ] = False
         # Assign the number of large connected components
-        annotations_enrichment_matrix.loc[attribute, "num_large_connected_components"] = (
+        annotations_significance_matrix.loc[attribute, "num_large_connected_components"] = (
             num_large_connected_components
         )
         # Assign the size of connected components, ensuring it is always a list
-        annotations_enrichment_matrix.at[attribute, "size_connected_components"] = (
+        annotations_significance_matrix.at[attribute, "size_connected_components"] = (
             filtered_size_connected_components.tolist()
         )
 
-    return annotations_enrichment_matrix
+    return annotations_significance_matrix
 
 
 def get_weighted_description(words_column: pd.Series, scores_column: pd.Series) -> str:
@@ -184,16 +185,16 @@ def get_weighted_description(words_column: pd.Series, scores_column: pd.Series)
 
     Args:
         words_column (pd.Series): A pandas Series containing strings to process.
-        scores_column (pd.Series): A pandas Series containing enrichment scores to weigh the terms.
+        scores_column (pd.Series): A pandas Series containing significance scores to weigh the terms.
 
     Returns:
-        str: A coherent description formed from the most frequent and significant words, weighed by enrichment scores.
+        str: A coherent description formed from the most frequent and significant words, weighed by significance scores.
     """
     # Handle case where all scores are the same
     if scores_column.max() == scores_column.min():
         normalized_scores = pd.Series([1] * len(scores_column))
     else:
-        # Normalize the enrichment scores to be between 0 and 1
+        # Normalize the significance scores to be between 0 and 1
         normalized_scores = (scores_column - scores_column.min()) / (
             scores_column.max() - scores_column.min()
         )

risk/log/enrichment.py

@@ -0,0 +1,18 @@
+"""
+risk/log/enrichment
+~~~~~~~~~~~~~~~~~~~
+"""
+
+import csv
+import json
+import warnings
+from datetime import datetime
+from functools import wraps
+from typing import Any, Dict
+
+import numpy as np
+
+from .console import logger, log_header
+
+# Suppress all warnings - this is to resolve warnings from multiprocessing
+warnings.filterwarnings("ignore")

risk/neighborhoods/domains.py

@@ -20,17 +20,17 @@ from risk.log import logger
 
 def define_domains(
     top_annotations: pd.DataFrame,
-    significant_neighborhoods_enrichment: np.ndarray,
+    significant_neighborhoods_significance: np.ndarray,
     linkage_criterion: str,
     linkage_method: str,
     linkage_metric: str,
 ) -> pd.DataFrame:
-    """Define domains and assign nodes to these domains based on their enrichment scores and clustering,
+    """Define domains and assign nodes to these domains based on their significance scores and clustering,
     handling errors by assigning unique domains when clustering fails.
 
     Args:
         top_annotations (pd.DataFrame): DataFrame of top annotations data for the network nodes.
-        significant_neighborhoods_enrichment (np.ndarray): The binary enrichment matrix below alpha.
+        significant_neighborhoods_significance (np.ndarray): The binary significance matrix below alpha.
         linkage_criterion (str): The clustering criterion for defining groups.
         linkage_method (str): The linkage method for clustering.
         linkage_metric (str): The linkage metric for clustering.
@@ -40,7 +40,7 @@ def define_domains(
     """
     try:
         # Transpose the matrix to cluster annotations
-        m = significant_neighborhoods_enrichment[:, top_annotations["significant_annotations"]].T
+        m = significant_neighborhoods_significance[:, top_annotations["significant_annotations"]].T
         best_linkage, best_metric, best_threshold = _optimize_silhouette_across_linkage_and_metrics(
             m, linkage_criterion, linkage_method, linkage_metric
         )
@@ -65,13 +65,13 @@ def define_domains(
         top_annotations["domain"] = range(1, n_rows + 1)  # Assign unique domains
 
     # Create DataFrames to store domain information
-    node_to_enrichment = pd.DataFrame(
-        data=significant_neighborhoods_enrichment,
+    node_to_significance = pd.DataFrame(
+        data=significant_neighborhoods_significance,
         columns=[top_annotations.index.values, top_annotations["domain"]],
     )
-    node_to_domain = node_to_enrichment.groupby(level="domain", axis=1).sum()
+    node_to_domain = node_to_significance.groupby(level="domain", axis=1).sum()
 
-    # Find the maximum enrichment score for each node
+    # Find the maximum significance score for each node
     t_max = node_to_domain.loc[:, 1:].max(axis=1)
     t_idxmax = node_to_domain.loc[:, 1:].idxmax(axis=1)
     t_idxmax[t_max == 0] = 0
@@ -119,27 +119,27 @@ def trim_domains_and_top_annotations(
     top_annotations["domain"].replace(to_remove, invalid_domain_id, inplace=True)
     domains.loc[domains["primary_domain"].isin(to_remove), ["primary_domain"]] = invalid_domain_id
 
-    # Normalize "num enriched neighborhoods" by percentile for each domain and scale to 0-10
+    # Normalize "num significant neighborhoods" by percentile for each domain and scale to 0-10
     top_annotations["normalized_value"] = top_annotations.groupby("domain")[
-        "significant_neighborhood_enrichment_sums"
+        "significant_neighborhood_significance_sums"
     ].transform(lambda x: (x.rank(pct=True) * 10).apply(np.ceil).astype(int))
-    # Modify the lambda function to pass both full_terms and significant_enrichment_score
+    # Modify the lambda function to pass both full_terms and significant_significance_score
     top_annotations["combined_terms"] = top_annotations.apply(
         lambda row: " ".join([str(row["full_terms"])] * row["normalized_value"]), axis=1
     )
 
-    # Perform the groupby operation while retaining the other columns and adding the weighting with enrichment scores
+    # Perform the groupby operation while retaining the other columns and adding the weighting with significance scores
     domain_labels = (
         top_annotations.groupby("domain")
         .agg(
             full_terms=("full_terms", lambda x: list(x)),
-            enrichment_scores=("significant_enrichment_score", lambda x: list(x)),
+            significance_scores=("significant_significance_score", lambda x: list(x)),
         )
         .reset_index()
     )
     domain_labels["combined_terms"] = domain_labels.apply(
         lambda row: get_weighted_description(
-            pd.Series(row["full_terms"]), pd.Series(row["enrichment_scores"])
+            pd.Series(row["full_terms"]), pd.Series(row["significance_scores"])
         ),
         axis=1,
     )
@@ -150,7 +150,7 @@ def trim_domains_and_top_annotations(
             "domain": "id",
             "combined_terms": "normalized_description",
             "full_terms": "full_descriptions",
-            "enrichment_scores": "enrichment_scores",
+            "significance_scores": "significance_scores",
         }
     ).set_index("id")
 

risk/neighborhoods/neighborhoods.py

@@ -171,163 +171,169 @@ def process_neighborhoods(
 
     Args:
         network (nx.Graph): The network data structure used for imputing and pruning neighbors.
-        neighborhoods (Dict[str, Any]): Dictionary containing 'enrichment_matrix', 'significant_binary_enrichment_matrix', and 'significant_enrichment_matrix'.
+        neighborhoods (Dict[str, Any]): Dictionary containing 'significance_matrix', 'significant_binary_significance_matrix', and 'significant_significance_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[str, Any]: Processed neighborhoods data, including the updated matrices and enrichment counts.
+        Dict[str, Any]: Processed neighborhoods data, including the updated matrices and significance counts.
     """
-    enrichment_matrix = neighborhoods["enrichment_matrix"]
-    significant_binary_enrichment_matrix = neighborhoods["significant_binary_enrichment_matrix"]
-    significant_enrichment_matrix = neighborhoods["significant_enrichment_matrix"]
+    significance_matrix = neighborhoods["significance_matrix"]
+    significant_binary_significance_matrix = neighborhoods["significant_binary_significance_matrix"]
+    significant_significance_matrix = neighborhoods["significant_significance_matrix"]
     logger.debug(f"Imputation depth: {impute_depth}")
     if impute_depth:
         (
-            enrichment_matrix,
-            significant_binary_enrichment_matrix,
-            significant_enrichment_matrix,
+            significance_matrix,
+            significant_binary_significance_matrix,
+            significant_significance_matrix,
         ) = _impute_neighbors(
             network,
-            enrichment_matrix,
-            significant_binary_enrichment_matrix,
+            significance_matrix,
+            significant_binary_significance_matrix,
             max_depth=impute_depth,
         )
 
     logger.debug(f"Pruning threshold: {prune_threshold}")
     if prune_threshold:
         (
-            enrichment_matrix,
-            significant_binary_enrichment_matrix,
-            significant_enrichment_matrix,
+            significance_matrix,
+            significant_binary_significance_matrix,
+            significant_significance_matrix,
         ) = _prune_neighbors(
             network,
-            enrichment_matrix,
-            significant_binary_enrichment_matrix,
+            significance_matrix,
+            significant_binary_significance_matrix,
             distance_threshold=prune_threshold,
         )
 
-    neighborhood_enrichment_counts = np.sum(significant_binary_enrichment_matrix, axis=0)
-    node_enrichment_sums = np.sum(enrichment_matrix, axis=1)
+    neighborhood_significance_counts = np.sum(significant_binary_significance_matrix, axis=0)
+    node_significance_sums = np.sum(significance_matrix, axis=1)
     return {
-        "enrichment_matrix": 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,
+        "significance_matrix": significance_matrix,
+        "significant_binary_significance_matrix": significant_binary_significance_matrix,
+        "significant_significance_matrix": significant_significance_matrix,
+        "neighborhood_significance_counts": neighborhood_significance_counts,
+        "node_significance_sums": node_significance_sums,
     }
 
 
 def _impute_neighbors(
     network: nx.Graph,
-    enrichment_matrix: np.ndarray,
-    significant_binary_enrichment_matrix: np.ndarray,
+    significance_matrix: np.ndarray,
+    significant_binary_significance_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.
+    """Impute rows with sums of zero in the significance matrix based on the closest non-zero neighbors in the network graph.
 
     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.
-        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significance_matrix (np.ndarray): The significance matrix with rows to be imputed.
+        significant_binary_significance_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         max_depth (int): Maximum depth of nodes to traverse for imputing values.
 
     Returns:
         tuple: A tuple containing:
-            - np.ndarray: The imputed enrichment matrix.
+            - np.ndarray: The imputed significance matrix.
             - np.ndarray: The imputed alpha threshold matrix.
-            - np.ndarray: The significant enrichment matrix with non-significant entries set to zero.
+            - np.ndarray: The significant significance matrix with non-significant entries set to zero.
     """
     # Calculate the distance threshold value based on the shortest distances
-    enrichment_matrix, significant_binary_enrichment_matrix = _impute_neighbors_with_similarity(
-        network, enrichment_matrix, significant_binary_enrichment_matrix, max_depth=max_depth
+    significance_matrix, significant_binary_significance_matrix = _impute_neighbors_with_similarity(
+        network, significance_matrix, significant_binary_significance_matrix, max_depth=max_depth
     )
     # Create a matrix where non-significant entries are set to zero
-    significant_enrichment_matrix = np.where(
-        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    significant_significance_matrix = np.where(
+        significant_binary_significance_matrix == 1, significance_matrix, 0
     )
 
-    return enrichment_matrix, significant_binary_enrichment_matrix, significant_enrichment_matrix
+    return (
+        significance_matrix,
+        significant_binary_significance_matrix,
+        significant_significance_matrix,
+    )
 
 
 def _impute_neighbors_with_similarity(
     network: nx.Graph,
-    enrichment_matrix: np.ndarray,
-    significant_binary_enrichment_matrix: np.ndarray,
+    significance_matrix: np.ndarray,
+    significant_binary_significance_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.
+    """Impute non-significant nodes based on the closest significant neighbors' profiles and their 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.
-        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significance_matrix (np.ndarray): The significance matrix with rows to be imputed.
+        significant_binary_significance_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         max_depth (int): Maximum depth of nodes to traverse for imputing values.
 
     Returns:
         Tuple[np.ndarray, np.ndarray]: A tuple containing:
-            - The imputed enrichment matrix.
+            - The imputed significance matrix.
             - The imputed alpha threshold matrix.
     """
     depth = 1
-    rows_to_impute = np.where(significant_binary_enrichment_matrix.sum(axis=1) == 0)[0]
+    rows_to_impute = np.where(significant_binary_significance_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(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,
+        # Iterate over all significant nodes
+        for row_index in range(significant_binary_significance_matrix.shape[0]):
+            if significant_binary_significance_matrix[row_index].sum() != 0:
+                significance_matrix, significant_binary_significance_matrix = (
+                    _process_node_imputation(
+                        row_index,
+                        network,
+                        significance_matrix,
+                        significant_binary_significance_matrix,
+                        depth,
+                    )
                 )
 
         # Update rows to impute for the next iteration
-        rows_to_impute = np.where(significant_binary_enrichment_matrix.sum(axis=1) == 0)[0]
+        rows_to_impute = np.where(significant_binary_significance_matrix.sum(axis=1) == 0)[0]
         depth += 1
 
-    return enrichment_matrix, significant_binary_enrichment_matrix
+    return significance_matrix, significant_binary_significance_matrix
 
 
 def _process_node_imputation(
     row_index: int,
     network: nx.Graph,
-    enrichment_matrix: np.ndarray,
-    significant_binary_enrichment_matrix: np.ndarray,
+    significance_matrix: np.ndarray,
+    significant_binary_significance_matrix: np.ndarray,
     depth: int,
 ) -> Tuple[np.ndarray, np.ndarray]:
-    """Process the imputation for a single node based on its enriched neighbors.
+    """Process the imputation for a single node based on its significant neighbors.
 
     Args:
-        row_index (int): The index of the enriched node being processed.
+        row_index (int): The index of the significant 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.
-        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
+        significance_matrix (np.ndarray): The significance matrix with rows to be imputed.
+        significant_binary_significance_matrix (np.ndarray): The alpha threshold matrix to be imputed similarly.
         depth (int): Current depth for traversal.
 
     Returns:
-        Tuple[np.ndarray, np.ndarray]: The modified enrichment matrix and binary threshold matrix.
+        Tuple[np.ndarray, np.ndarray]: The modified significance matrix and binary threshold matrix.
     """
     # Check neighbors at the current depth
     neighbors = nx.single_source_shortest_path_length(network, row_index, cutoff=depth)
-    # Filter annotated neighbors (already enriched)
+    # Filter annotated neighbors (already significant)
     annotated_neighbors = [
         n
         for n in neighbors
         if n != row_index
-        and significant_binary_enrichment_matrix[n].sum() != 0
-        and enrichment_matrix[n].sum() != 0
+        and significant_binary_significance_matrix[n].sum() != 0
+        and significance_matrix[n].sum() != 0
     ]
-    # Filter non-enriched neighbors
+    # Filter non-significant neighbors
     valid_neighbors = [
         n
         for n in neighbors
         if n != row_index
-        and significant_binary_enrichment_matrix[n].sum() == 0
-        and enrichment_matrix[n].sum() == 0
+        and significant_binary_significance_matrix[n].sum() == 0
+        and significance_matrix[n].sum() == 0
     ]
-    # If there are valid non-enriched neighbors
+    # If there are valid non-significant neighbors
     if valid_neighbors and annotated_neighbors:
         # Calculate distances to annotated neighbors
         distances_to_annotated = [
@@ -338,7 +344,7 @@ def _process_node_imputation(
         iqr = q3 - q1
         lower_bound = q1 - 1.5 * iqr
         upper_bound = q3 + 1.5 * iqr
-        # Filter valid non-enriched neighbors that fall within the IQR bounds
+        # Filter valid non-significant neighbors that fall within the IQR bounds
         valid_neighbors_within_iqr = [
             n
             for n in valid_neighbors
@@ -352,8 +358,8 @@ def _process_node_imputation(
                 def sum_pairwise_cosine_similarities(neighbor):
                     return sum(
                         cosine_similarity(
-                            enrichment_matrix[neighbor].reshape(1, -1),
-                            enrichment_matrix[other_neighbor].reshape(1, -1),
+                            significance_matrix[neighbor].reshape(1, -1),
+                            significance_matrix[other_neighbor].reshape(1, -1),
                         )[0][0]
                         for other_neighbor in valid_neighbors_within_iqr
                         if other_neighbor != neighbor
@@ -365,43 +371,45 @@ def _process_node_imputation(
             else:
                 most_similar_neighbor = valid_neighbors_within_iqr[0]
 
-            # Impute the most similar non-enriched neighbor with the enriched node's data, scaled by depth
-            enrichment_matrix[most_similar_neighbor] = enrichment_matrix[row_index] / np.sqrt(
+            # Impute the most similar non-significant neighbor with the significant node's data, scaled by depth
+            significance_matrix[most_similar_neighbor] = significance_matrix[row_index] / np.sqrt(
                 depth + 1
             )
-            significant_binary_enrichment_matrix[most_similar_neighbor] = (
-                significant_binary_enrichment_matrix[row_index]
+            significant_binary_significance_matrix[most_similar_neighbor] = (
+                significant_binary_significance_matrix[row_index]
             )
 
-    return enrichment_matrix, significant_binary_enrichment_matrix
+    return significance_matrix, significant_binary_significance_matrix
 
 
 def _prune_neighbors(
     network: nx.Graph,
-    enrichment_matrix: np.ndarray,
-    significant_binary_enrichment_matrix: np.ndarray,
+    significance_matrix: np.ndarray,
+    significant_binary_significance_matrix: np.ndarray,
     distance_threshold: float = 0.9,
 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Remove outliers based on their rank for edge lengths.
 
     Args:
         network (nx.Graph): The network graph with nodes having IDs matching the matrix indices.
-        enrichment_matrix (np.ndarray): The enrichment matrix.
-        significant_binary_enrichment_matrix (np.ndarray): The alpha threshold matrix.
+        significance_matrix (np.ndarray): The significance matrix.
+        significant_binary_significance_matrix (np.ndarray): The alpha threshold matrix.
         distance_threshold (float): Rank threshold (0 to 1) to determine outliers.
 
     Returns:
         tuple: A tuple containing:
-            - np.ndarray: The updated enrichment matrix with outliers set to zero.
+            - np.ndarray: The updated significance matrix with outliers set to zero.
             - np.ndarray: The updated alpha threshold matrix with outliers set to zero.
-            - np.ndarray: The significant enrichment matrix, where non-significant entries are set to zero.
+            - np.ndarray: The significant significance 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(significant_binary_enrichment_matrix.sum(axis=1) != 0)[0]
+    # Identify indices with non-zero rows in the binary significance matrix
+    non_zero_indices = np.where(significant_binary_significance_matrix.sum(axis=1) != 0)[0]
     median_distances = []
     for node in non_zero_indices:
         neighbors = [
-            n for n in network.neighbors(node) if significant_binary_enrichment_matrix[n].sum() != 0
+            n
+            for n in network.neighbors(node)
+            if significant_binary_significance_matrix[n].sum() != 0
         ]
         if neighbors:
             median_distance = np.median(
@@ -416,22 +424,26 @@ def _prune_neighbors(
         neighbors = [
             n
             for n in network.neighbors(row_index)
-            if significant_binary_enrichment_matrix[n].sum() != 0
+            if significant_binary_significance_matrix[n].sum() != 0
         ]
         if neighbors:
             median_distance = np.median(
                 [_get_euclidean_distance(row_index, n, network) for n in neighbors]
             )
             if median_distance >= distance_threshold_value:
-                enrichment_matrix[row_index] = 0
-                significant_binary_enrichment_matrix[row_index] = 0
+                significance_matrix[row_index] = 0
+                significant_binary_significance_matrix[row_index] = 0
 
     # Create a matrix where non-significant entries are set to zero
-    significant_enrichment_matrix = np.where(
-        significant_binary_enrichment_matrix == 1, enrichment_matrix, 0
+    significant_significance_matrix = np.where(
+        significant_binary_significance_matrix == 1, significance_matrix, 0
     )
 
-    return enrichment_matrix, significant_binary_enrichment_matrix, significant_enrichment_matrix
+    return (
+        significance_matrix,
+        significant_binary_significance_matrix,
+        significant_significance_matrix,
+    )
 
 
 def _get_euclidean_distance(node1: Any, node2: Any, network: nx.Graph) -> float: