risk-network 0.0.9b37__tar.gz → 0.0.9b39__tar.gz

{risk_network-0.0.9b37 → risk_network-0.0.9b39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: risk-network
-Version: 0.0.9b37
+Version: 0.0.9b39
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>

{risk_network-0.0.9b37 → risk_network-0.0.9b39}/risk/__init__.py

@@ -7,4 +7,4 @@ RISK: Regional Inference of Significant Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.9-beta.37"
+__version__ = "0.0.9-beta.39"

{risk_network-0.0.9b37 → risk_network-0.0.9b39}/risk/neighborhoods/domains.py

@@ -10,7 +10,7 @@ from typing import Tuple, Union
 import numpy as np
 import pandas as pd
 from scipy.cluster.hierarchy import linkage, fcluster
-from sklearn.metrics import calinski_harabasz_score, davies_bouldin_score, silhouette_score
+from sklearn.metrics import silhouette_score
 from tqdm import tqdm
 
 from risk.annotations import get_weighted_description
@@ -18,19 +18,13 @@ from risk.constants import GROUP_LINKAGE_METHODS, GROUP_DISTANCE_METRICS
 from risk.log import logger
 
 
-class LinkageThresholdError(Exception):
-    """Exception raised for errors in the linkage threshold optimization process."""
-
-    pass
-
-
 def define_domains(
     top_annotations: pd.DataFrame,
     significant_neighborhoods_significance: np.ndarray,
     linkage_criterion: str,
     linkage_method: str,
     linkage_metric: str,
-    linkage_threshold: Union[str, float],
+    linkage_threshold: float,
 ) -> pd.DataFrame:
     """Define domains and assign nodes to these domains based on their significance scores and clustering,
     handling errors by assigning unique domains when clustering fails.
@@ -38,19 +32,13 @@ def define_domains(
     Args:
         top_annotations (pd.DataFrame): DataFrame of top annotations data for the network nodes.
         significant_neighborhoods_significance (np.ndarray): The binary significance matrix below alpha.
-        linkage_criterion (str): The clustering criterion for defining groups. Use "distance" for distance-based
-            clustering or "maxclust" for a fixed number of clusters. Use "off" to skip clustering.
-        linkage_method (str): The linkage method for clustering. Use "auto" to try multiple methods.
-        linkage_metric (str): The linkage metric for clustering. Use "auto" to try multiple metrics.
-        linkage_threshold (float): The linkage threshold for clustering, or one of "silhouette", "calinski_harabasz",
-            or "davies_bouldin" to optimize the threshold.
+        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.
+        linkage_threshold (float): The threshold for clustering.
 
     Returns:
         pd.DataFrame: DataFrame with the primary domain for each node.
-
-    Raises:
-        ValueError: If an improper value is passed for linkage_threshold. Acceptable values are "silhouette",
-            "calinski_harabasz", "davies_bouldin", or a float value.
     """
     try:
         if linkage_criterion == "off":
@@ -61,10 +49,8 @@ def define_domains(
         # Safeguard the matrix by replacing NaN, Inf, and -Inf values
         m = _safeguard_matrix(m)
         # Optimize silhouette score across different linkage methods and distance metrics
-        best_linkage, best_metric, best_threshold = (
-            _optimize_linkage_threshold_across_methods_and_metrics(
-                m, linkage_criterion, linkage_method, linkage_metric, linkage_threshold
-            )
+        best_linkage, best_metric, best_threshold = _optimize_silhouette_across_linkage_and_metrics(
+            m, linkage_criterion, linkage_method, linkage_metric, linkage_threshold
         )
         # Perform hierarchical clustering
         Z = linkage(m, method=best_linkage, metric=best_metric)
@@ -90,9 +76,6 @@ def define_domains(
                 f"Error encountered. Skipping clustering and assigning {n_rows} unique domains."
             )
         top_annotations["domain"] = range(1, n_rows + 1)  # Assign unique domains
-    except LinkageThresholdError as e:
-        # If a LinkageThresholdError is encountered, raise a ValueError with the original exception
-        raise ValueError(e) from e
 
     # Create DataFrames to store domain information
     node_to_significance = pd.DataFrame(
@@ -214,178 +197,146 @@ def _safeguard_matrix(matrix: np.ndarray) -> np.ndarray:
     return matrix
 
 
-def _optimize_linkage_threshold_across_methods_and_metrics(
+def _optimize_silhouette_across_linkage_and_metrics(
     m: np.ndarray,
     linkage_criterion: str,
     linkage_method: str,
     linkage_metric: str,
     linkage_threshold: Union[str, float],
 ) -> Tuple[str, str, float]:
-    """Optimize the linkage method, metric, and threshold for hierarchical clustering. If the threshold is
-    a string, optimize the threshold using the specified metric; otherwise, use the provided threshold.
+    """Optimize silhouette score across different linkage methods and distance metrics.
 
     Args:
         m (np.ndarray): Data matrix.
-        linkage_criterion (str): Criterion for fcluster (typically "distance").
-        linkage_method (str): Linkage method for clustering, or "auto" to try multiple methods.
-        linkage_metric (str): Distance metric for clustering, or "auto" to try multiple metrics.
-        linkage_threshold (Union[str, float]): Either a numeric threshold or one of
-            "silhouette", "calinski_harabasz", or "davies_bouldin" to trigger optimization.
+        linkage_criterion (str): Clustering criterion.
+        linkage_method (str): Linkage method for clustering.
+        linkage_metric (str): Linkage metric for clustering.
+        linkage_threshold (Union[str, float]): Threshold for clustering. Set to "auto" to optimize.
 
     Returns:
         Tuple[str, str, float]:
-            - The chosen linkage method.
-            - The chosen linkage metric.
-            - The optimized threshold (a float).
-
-    Raises:
-        ValueError: If linkage_threshold is neither one of the supported keywords nor convertible to float.
+            - Best linkage method (str)
+            - Best linkage metric (str)
+            - Best threshold (float)
     """
-    # Supported linkage threshold metrics
-    supported_linkage_thresholds = {"silhouette", "calinski_harabasz", "davies_bouldin"}
-
-    # If linkage_threshold is a string:
-    if isinstance(linkage_threshold, str):
-        if linkage_threshold in supported_linkage_thresholds:
-            opt_metric = linkage_threshold
-        else:
-            try:
-                threshold_float = float(linkage_threshold)
-            except (TypeError, ValueError):
-                raise LinkageThresholdError(
-                    f"linkage_threshold must be one of {', '.join(supported_linkage_thresholds)} or a float value."
-                )
-            return linkage_method, linkage_metric, threshold_float
-    else:
-        # If not a string, try to convert it to float.
-        try:
-            threshold_float = float(linkage_threshold)
-        except (TypeError, ValueError):
-            raise LinkageThresholdError(
-                f"linkage_threshold must be one of {', '.join(supported_linkage_thresholds)} or a float value."
-            )
-        return linkage_method, linkage_metric, threshold_float
-
-    # Otherwise, perform optimization using the specified metric (opt_metric).
-    best_overall_method = None
-    best_overall_metric = None
-    best_overall_threshold = None
+    # Initialize best overall values
+    best_overall_method = linkage_method
+    best_overall_metric = linkage_metric
+    best_overall_threshold = linkage_threshold
     best_overall_score = -np.inf
 
-    # Use the provided lists if "auto" is specified.
-    methods = GROUP_LINKAGE_METHODS if linkage_method == "auto" else [linkage_method]
-    metrics = GROUP_DISTANCE_METRICS if linkage_metric == "auto" else [linkage_metric]
-    total_combinations = len(methods) * len(metrics)
+    # Set linkage methods and metrics to all combinations if "auto" is selected
+    linkage_methods = GROUP_LINKAGE_METHODS if linkage_method == "auto" else [linkage_method]
+    linkage_metrics = GROUP_DISTANCE_METRICS if linkage_metric == "auto" else [linkage_metric]
+    total_combinations = len(linkage_methods) * len(linkage_metrics)
 
+    # Evaluating optimal linkage method and metric
     for method, metric in tqdm(
-        product(methods, metrics),
+        product(linkage_methods, linkage_metrics),
         desc="Evaluating optimal linkage method and metric",
         total=total_combinations,
         bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]",
     ):
+        # Some linkage methods and metrics may not work with certain data
         with suppress(ValueError):
             Z = linkage(m, method=method, metric=metric)
-            threshold, score = _find_optimal_linkage_threshold(
-                Z, m, metric, linkage_criterion, opt_metric=opt_metric
-            )
-            if score > best_overall_score:
-                best_overall_score = score
-                best_overall_threshold = threshold
-                best_overall_method = method
-                best_overall_metric = metric
-
-    if best_overall_method is None or best_overall_metric is None or best_overall_threshold is None:
-        raise ValueError("Optimization failed to determine an optimal threshold.")
+            # Only optimize silhouette score if the threshold is "auto"
+            if linkage_threshold == "auto":
+                threshold, score = _find_best_silhouette_score(Z, m, metric, linkage_criterion)
+                if score > best_overall_score:
+                    best_overall_score = score
+                    best_overall_threshold = threshold
+                    best_overall_method = method
+                    best_overall_metric = metric
+            else:
+                # Use the provided threshold without optimization
+                score = silhouette_score(
+                    m,
+                    fcluster(Z, linkage_threshold * np.max(Z[:, 2]), criterion=linkage_criterion),
+                    metric=metric,
+                )
+                if score > best_overall_score:
+                    best_overall_score = score
+                    best_overall_threshold = linkage_threshold
+                    best_overall_method = method
+                    best_overall_metric = metric
+
     return best_overall_method, best_overall_metric, best_overall_threshold
 
 
-def _find_optimal_linkage_threshold(
+def _find_best_silhouette_score(
     Z: np.ndarray,
     m: np.ndarray,
     linkage_metric: str,
     linkage_criterion: str,
-    opt_metric: str = "silhouette",
+    lower_bound: float = 0.001,
+    upper_bound: float = 1.0,
+    resolution: float = 0.001,
 ) -> Tuple[float, float]:
-    """Find the optimal linkage threshold coefficient (multiplier for np.max(Z[:, 2])) via binary search.
-    The threshold is chosen to optimize clustering quality, as measured by the chosen metric.
+    """Find the best silhouette score using binary search.
 
     Args:
         Z (np.ndarray): Linkage matrix.
         m (np.ndarray): Data matrix.
-        linkage_metric (str): The metric used for clustering quality calculation.
-        linkage_criterion (str): The criterion to pass to fcluster (typically "distance").
-        opt_metric (str): The metric to optimize; one of "silhouette", "calinski_harabasz", or "davies_bouldin".
-            For "silhouette" and "calinski_harabasz", higher is better; for "davies_bouldin", lower is better.
+        linkage_metric (str): Linkage metric for silhouette score calculation.
+        linkage_criterion (str): Clustering criterion.
+        lower_bound (float, optional): Lower bound for search. Defaults to 0.001.
+        upper_bound (float, optional): Upper bound for search. Defaults to 1.0.
+        resolution (float, optional): Desired resolution for the best threshold. Defaults to 0.001.
 
     Returns:
         Tuple[float, float]:
-            - best_threshold: The optimal linkage coefficient for np.max(Z[:, 2]).
-            - best_metric_value: The clustering quality metric achieved (with higher being better for
-              "silhouette" and "calinski_harabasz", and lower for "davies_bouldin").
+            - Best threshold (float): The threshold that yields the best silhouette score.
+            - Best silhouette score (float): The highest silhouette score achieved.
     """
-    max_d = np.max(Z[:, 2])
-    lower_bound = 0.0
-    upper_bound = 1.0
-    resolution = 1e-6
-
-    def compute_objective(coefficient: float) -> float:
-        """Compute the objective function for a given linkage threshold coefficient."""
-        threshold_val = coefficient * max_d
-        clusters = fcluster(Z, threshold_val, criterion=linkage_criterion)
-        unique_clusters = np.unique(clusters)
-        # Return a heavy penalty if the clustering is trivial.
-        if len(unique_clusters) <= 1 or len(unique_clusters) == m.shape[0]:
-            return 1e6
-        try:
-            if opt_metric == "silhouette":
-                score = silhouette_score(m, clusters, metric=linkage_metric)
-                return -score  # We want to maximize the silhouette score.
-            elif opt_metric == "calinski_harabasz":
-                score = calinski_harabasz_score(m, clusters)
-                return -score  # Higher is better.
-            elif opt_metric == "davies_bouldin":
-                score = davies_bouldin_score(m, clusters)
-                return score  # Lower is better.
-            else:
-                raise LinkageThresholdError(f"Unknown optimization metric: {opt_metric}.")
-        except Exception:
-            return 1e6
-
-    # Initialize the bounds and the best objective value
-    obj_lower = compute_objective(lower_bound)
-    obj_upper = compute_objective(upper_bound)
-    # Determine the initial direction of the search
-    if obj_lower < obj_upper:
-        best_obj = obj_lower
+    best_score = -np.inf
+    best_threshold = None
+
+    # Test lower bound
+    max_d_lower = np.max(Z[:, 2]) * lower_bound
+    clusters_lower = fcluster(Z, max_d_lower, criterion=linkage_criterion)
+    try:
+        score_lower = silhouette_score(m, clusters_lower, metric=linkage_metric)
+    except ValueError:
+        score_lower = -np.inf
+
+    # Test upper bound
+    max_d_upper = np.max(Z[:, 2]) * upper_bound
+    clusters_upper = fcluster(Z, max_d_upper, criterion=linkage_criterion)
+    try:
+        score_upper = silhouette_score(m, clusters_upper, metric=linkage_metric)
+    except ValueError:
+        score_upper = -np.inf
+
+    # Determine initial bounds for binary search
+    if score_lower > score_upper:
+        best_score = score_lower
         best_threshold = lower_bound
-        lower = lower_bound
-        upper = (lower_bound + upper_bound) / 2
+        upper_bound = (lower_bound + upper_bound) / 2
     else:
-        best_obj = obj_upper
+        best_score = score_upper
         best_threshold = upper_bound
-        lower = (lower_bound + upper_bound) / 2
-        upper = upper_bound
-
-    # Perform binary search to find the optimal linkage threshold coefficient
-    while (upper - lower) > resolution:
-        mid = (upper + lower) / 2
-        obj_mid = compute_objective(mid)
-        if obj_mid < best_obj:
-            best_obj = obj_mid
-            best_threshold = mid
-
-        # Update the bounds based on the objective value
-        obj_left = compute_objective((lower + mid) / 2)
-        obj_right = compute_objective((mid + upper) / 2)
-        if obj_left < obj_right:
-            upper = mid
-        else:
-            lower = mid
+        lower_bound = (lower_bound + upper_bound) / 2
 
-    # If the optimization metric is silhouette or calinski_harabasz, return the negative value
-    if opt_metric in ["silhouette", "calinski_harabasz"]:
-        best_metric_value = -best_obj
-    else:
-        best_metric_value = best_obj
+    # Binary search loop
+    while upper_bound - lower_bound > resolution:
+        mid_threshold = (upper_bound + lower_bound) / 2
+        max_d_mid = np.max(Z[:, 2]) * mid_threshold
+        clusters_mid = fcluster(Z, max_d_mid, criterion=linkage_criterion)
+        try:
+            score_mid = silhouette_score(m, clusters_mid, metric=linkage_metric)
+        except ValueError:
+            score_mid = -np.inf
+
+        # Update best score and threshold if mid-point is better
+        if score_mid > best_score:
+            best_score = score_mid
+            best_threshold = mid_threshold
+
+        # Adjust bounds based on the scores
+        if score_lower > score_upper:
+            upper_bound = mid_threshold
+        else:
+            lower_bound = mid_threshold
 
-    return best_threshold, float(best_metric_value)
+    return best_threshold, float(best_score)

{risk_network-0.0.9b37 → risk_network-0.0.9b39}/risk_network.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: risk-network
-Version: 0.0.9b37
+Version: 0.0.9b39
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>