risk-network 0.0.9b26__py3-none-any.whl → 0.0.9b28__py3-none-any.whl

risk/stats/stat_tests.py

@@ -0,0 +1,272 @@
+"""
+risk/stats/stat_tests
+~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from typing import Any, Dict
+
+import numpy as np
+from scipy.sparse import csr_matrix
+from scipy.stats import binom
+from scipy.stats import chi2
+from scipy.stats import hypergeom
+from scipy.stats import norm
+from scipy.stats import poisson
+
+
+def compute_binom_test(
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
+) -> Dict[str, Any]:
+    """Compute Binomial test for enrichment and depletion in neighborhoods with selectable null distribution.
+
+    Args:
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+
+    Returns:
+        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+    """
+    # Get the total number of nodes in the network
+    total_nodes = neighborhoods.shape[1]
+
+    # Compute sums (remain sparse here)
+    neighborhood_sizes = neighborhoods.sum(axis=1)  # Row sums
+    annotation_totals = annotations.sum(axis=0)  # Column sums
+    # Compute probabilities (convert to dense)
+    if null_distribution == "network":
+        p_values = (annotation_totals / total_nodes).A.flatten()  # Dense 1D array
+    elif null_distribution == "annotations":
+        p_values = (annotation_totals / annotations.sum()).A.flatten()  # Dense 1D array
+    else:
+        raise ValueError(
+            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+        )
+
+    # Observed counts (sparse matrix multiplication)
+    annotated_counts = neighborhoods @ annotations  # Sparse result
+    annotated_counts_dense = annotated_counts.toarray()  # Convert for dense operations
+
+    # Compute enrichment and depletion p-values
+    enrichment_pvals = 1 - binom.cdf(annotated_counts_dense - 1, neighborhood_sizes.A, p_values)
+    depletion_pvals = binom.cdf(annotated_counts_dense, neighborhood_sizes.A, p_values)
+
+    return {"enrichment_pvals": enrichment_pvals, "depletion_pvals": depletion_pvals}
+
+
+def compute_chi2_test(
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
+) -> Dict[str, Any]:
+    """Compute chi-squared test for enrichment and depletion in neighborhoods with selectable null distribution.
+
+    Args:
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+
+    Returns:
+        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+    """
+    # Total number of nodes in the network
+    total_node_count = neighborhoods.shape[0]
+
+    if null_distribution == "network":
+        # Case 1: Use all nodes as the background
+        background_population = total_node_count
+        neighborhood_sums = neighborhoods.sum(axis=0)  # Column sums of neighborhoods
+        annotation_sums = annotations.sum(axis=0)  # Column sums of annotations
+    elif null_distribution == "annotations":
+        # Case 2: Only consider nodes with at least one annotation
+        annotated_nodes = (
+            np.ravel(annotations.sum(axis=1)) > 0
+        )  # Row-wise sum to filter nodes with annotations
+        background_population = annotated_nodes.sum()  # Total number of annotated nodes
+        neighborhood_sums = neighborhoods[annotated_nodes].sum(
+            axis=0
+        )  # Neighborhood sums for annotated nodes
+        annotation_sums = annotations[annotated_nodes].sum(
+            axis=0
+        )  # Annotation sums for annotated nodes
+    else:
+        raise ValueError(
+            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+        )
+
+    # Convert to dense arrays for downstream computations
+    neighborhood_sums = np.asarray(neighborhood_sums).reshape(-1, 1)  # Ensure column vector shape
+    annotation_sums = np.asarray(annotation_sums).reshape(1, -1)  # Ensure row vector shape
+
+    # Observed values: number of annotated nodes in each neighborhood
+    observed = neighborhoods.T @ annotations  # Shape: (neighborhoods, annotations)
+    # Expected values under the null
+    expected = (neighborhood_sums @ annotation_sums) / background_population
+    # Chi-squared statistic: sum((observed - expected)^2 / expected)
+    with np.errstate(divide="ignore", invalid="ignore"):  # Handle divide-by-zero
+        chi2_stat = np.where(expected > 0, np.power(observed - expected, 2) / expected, 0)
+
+    # Compute p-values for enrichment (upper tail) and depletion (lower tail)
+    enrichment_pvals = chi2.sf(chi2_stat, df=1)  # Survival function for upper tail
+    depletion_pvals = chi2.cdf(chi2_stat, df=1)  # Cumulative distribution for lower tail
+
+    return {"depletion_pvals": depletion_pvals, "enrichment_pvals": enrichment_pvals}
+
+
+def compute_hypergeom_test(
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
+) -> Dict[str, Any]:
+    """
+    Compute hypergeometric test for enrichment and depletion in neighborhoods with selectable null distribution.
+
+    Args:
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+
+    Returns:
+        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+    """
+    # Total number of nodes
+    total_nodes = neighborhoods.shape[1]
+
+    # Compute sums directly using sparse operations
+    neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()
+    annotation_sums = annotations.sum(axis=0).A.flatten()
+
+    if null_distribution == "network":
+        background_population = total_nodes
+    elif null_distribution == "annotations":
+        # Boolean mask for nodes with annotations
+        annotated_nodes = annotations.getnnz(axis=1) > 0
+        background_population = annotated_nodes.sum()
+        # Filter neighborhoods and annotations to include only annotated nodes
+        neighborhoods = neighborhoods[annotated_nodes]
+        annotations = annotations[annotated_nodes]
+        neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()
+        annotation_sums = annotations.sum(axis=0).A.flatten()
+    else:
+        raise ValueError(
+            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+        )
+
+    # Compute annotated nodes in each neighborhood
+    annotated_in_neighborhood = neighborhoods.T @ annotations  # Sparse multiplication
+    # Convert to dense arrays for vectorized operations
+    annotated_in_neighborhood = annotated_in_neighborhood.toarray()
+    # Align shapes for broadcasting
+    neighborhood_sums = neighborhood_sums[:, np.newaxis]
+    annotation_sums = annotation_sums[np.newaxis, :]
+    background_population = np.array([[background_population]])
+
+    # Fully vectorized hypergeometric calculations
+    depletion_pvals = hypergeom.cdf(
+        annotated_in_neighborhood, background_population, annotation_sums, neighborhood_sums
+    )
+    enrichment_pvals = hypergeom.sf(
+        annotated_in_neighborhood - 1, background_population, annotation_sums, neighborhood_sums
+    )
+
+    return {"depletion_pvals": depletion_pvals, "enrichment_pvals": enrichment_pvals}
+
+
+def compute_poisson_test(
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
+) -> Dict[str, Any]:
+    """
+    Compute Poisson test for enrichment and depletion in neighborhoods with selectable null distribution.
+
+    Args:
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+
+    Returns:
+        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+    """
+    # Matrix multiplication to get the number of annotated nodes in each neighborhood
+    annotated_in_neighborhood = neighborhoods @ annotations  # Sparse result
+    # Convert annotated counts to dense for downstream calculations
+    annotated_in_neighborhood_dense = annotated_in_neighborhood.toarray()
+
+    # Compute lambda_expected based on the chosen null distribution
+    if null_distribution == "network":
+        # Use the mean across neighborhoods (axis=1)
+        lambda_expected = np.mean(annotated_in_neighborhood_dense, axis=1, keepdims=True)
+    elif null_distribution == "annotations":
+        # Use the mean across annotations (axis=0)
+        lambda_expected = np.mean(annotated_in_neighborhood_dense, axis=0, keepdims=True)
+    else:
+        raise ValueError(
+            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+        )
+
+    # Compute p-values for enrichment and depletion using Poisson distribution
+    enrichment_pvals = 1 - poisson.cdf(annotated_in_neighborhood_dense - 1, lambda_expected)
+    depletion_pvals = poisson.cdf(annotated_in_neighborhood_dense, lambda_expected)
+
+    return {"enrichment_pvals": enrichment_pvals, "depletion_pvals": depletion_pvals}
+
+
+def compute_zscore_test(
+    neighborhoods: csr_matrix,
+    annotations: csr_matrix,
+    null_distribution: str = "network",
+) -> Dict[str, Any]:
+    """
+    Compute Z-score test for enrichment and depletion in neighborhoods with selectable null distribution.
+
+    Args:
+        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
+        annotations (csr_matrix): Sparse binary matrix representing annotations.
+        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
+
+    Returns:
+        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
+    """
+    # Total number of nodes in the network
+    total_node_count = neighborhoods.shape[1]
+
+    # Compute sums
+    if null_distribution == "network":
+        background_population = total_node_count
+        neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()  # Dense column sums
+        annotation_sums = annotations.sum(axis=0).A.flatten()  # Dense row sums
+    elif null_distribution == "annotations":
+        annotated_nodes = annotations.sum(axis=1).A.flatten() > 0  # Dense boolean mask
+        background_population = annotated_nodes.sum()
+        neighborhood_sums = neighborhoods[annotated_nodes].sum(axis=0).A.flatten()
+        annotation_sums = annotations[annotated_nodes].sum(axis=0).A.flatten()
+    else:
+        raise ValueError(
+            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
+        )
+
+    # Observed values
+    observed = (neighborhoods.T @ annotations).toarray()  # Convert sparse result to dense
+    # Expected values under the null
+    neighborhood_sums = neighborhood_sums.reshape(-1, 1)  # Ensure correct shape
+    annotation_sums = annotation_sums.reshape(1, -1)  # Ensure correct shape
+    expected = (neighborhood_sums @ annotation_sums) / background_population
+
+    # Standard deviation under the null
+    std_dev = np.sqrt(
+        expected
+        * (1 - annotation_sums / background_population)
+        * (1 - neighborhood_sums / background_population)
+    )
+    std_dev[std_dev == 0] = np.nan  # Avoid division by zero
+    # Compute Z-scores
+    z_scores = (observed - expected) / std_dev
+
+    # Convert Z-scores to depletion and enrichment p-values
+    enrichment_pvals = norm.sf(z_scores)  # Upper tail
+    depletion_pvals = norm.cdf(z_scores)  # Lower tail
+
+    return {"depletion_pvals": depletion_pvals, "enrichment_pvals": enrichment_pvals}

{risk_network-0.0.9b26.dist-info → risk_network-0.0.9b28.dist-info}/METADATA

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

risk_network-0.0.9b28.dist-info/RECORD

@@ -0,0 +1,41 @@
+risk/__init__.py,sha256=32Lq_wPcVY8stW7c0jkvgihM15jnYka5Hnw8M9gbjN0,127
+risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
+risk/risk.py,sha256=s827_lRknFseOP9O4zW8sP-IcCd2EzrpV_tnVY_tz5s,1104
+risk/annotations/__init__.py,sha256=parsbcux1U4urpUqh9AdzbDWuLj9HlMidycMPkpSQFo,179
+risk/annotations/annotations.py,sha256=g8ca9H49dZIqHv6Od3Dem4BIo_euy8alL3PDauT6ZJI,14088
+risk/annotations/io.py,sha256=z1AJySsU-KL_IYuHa7j3nvuczmOHgK3WfaQ4TRunvrA,10499
+risk/log/__init__.py,sha256=7LxDysQu7doi0LAvlY2YbjN6iJH0fNknqy8lSLgeljo,217
+risk/log/console.py,sha256=PgjyEvyhYLUSHXPUKEqOmxsDsfrjPICIgqo_cAHq0N8,4575
+risk/log/parameters.py,sha256=VtwfMzLU1xI4yji3-Ch5vHjH-KdwTfwaEMmi7hFQTs0,5716
+risk/neighborhoods/__init__.py,sha256=Q74HwTH7okI-vaskJPy2bYwb5sNjGASTzJ6m8V8arCU,234
+risk/neighborhoods/api.py,sha256=TjIMVnSPC702zMlwyaz2i0ofNx-d9L9g3P-TTSBMx90,23341
+risk/neighborhoods/community.py,sha256=5Q_-VAJC-5SY5EUsB8gIlemeDoAL85uLjyl16pItHiQ,16699
+risk/neighborhoods/domains.py,sha256=jMJ4-Qzwgmo6Hya8h0E2_IcMaLpbuH_FWlmSjJl2ikc,12832
+risk/neighborhoods/neighborhoods.py,sha256=l9FhADB1C-OxM8E9QXOcA4osUDgA1vs4ud-OCGKKybc,21457
+risk/network/__init__.py,sha256=oVi3FA1XXKD84014Cykq-9bpX4_s0F3aAUfNOU-07Qw,73
+risk/network/geometry.py,sha256=dU1hMq4j9gG0nkDqGRl_NiZ2Z-xvT_HF11FwEQ7oOR4,6570
+risk/network/io.py,sha256=PqsRw1g7nfJJ3xs4aYcim3JWWLMFS1irgtg5hIyht5I,24376
+risk/network/graph/__init__.py,sha256=ziGJew3yhtqvrb9LUuneDu_LwW2Wa9vd4UuhoL5l1CA,91
+risk/network/graph/api.py,sha256=t5Mh5_lD2uTLioEJFfCRe7ncc5iLNYzxd6r05wSiv7s,8169
+risk/network/graph/graph.py,sha256=qEWyZvuaGT_vvjhreBdmRPX3gst2wQFaXhFAvikPSqw,12158
+risk/network/graph/summary.py,sha256=eYJP78EHxu3ZhKoDCFshNxuEIB3dvH0PUg2T7qNkjC8,10289
+risk/network/plotter/__init__.py,sha256=4gWtQHGzQVNHmEBXi31Zf0tX0y2sTcE66J_yGnn7268,99
+risk/network/plotter/api.py,sha256=oJIj7vYv-3VpfN41ndCNtxcWIuhT2ULwAaPPU2f4oeM,1785
+risk/network/plotter/canvas.py,sha256=ifyTMyXYRzlcdSYy6C23k3dmwtbLDrOfdMvEjkW2gLg,13460
+risk/network/plotter/contour.py,sha256=oQDKmAKaEasnK1zqY7_bNctZ_IevZW2vxrbsnSrOSCI,15459
+risk/network/plotter/labels.py,sha256=k5GWvgHS8bLekJk7Gtxy6G7tDeJDZPQ-z3VxYWjAWRM,45489
+risk/network/plotter/network.py,sha256=0VySlJ4n3tkHsOhVVSa3yiSppT8y1dmIwa-DhRn0tcM,14131
+risk/network/plotter/plotter.py,sha256=4PeAeutJbgvwy4USh5RdHALLtkmeAtaxQcd48r7Zxa0,5999
+risk/network/plotter/utils/colors.py,sha256=VU1sLPRC99ll6EGK4vRNgLMUXU8lja1vjiXUL8GdfBE,18910
+risk/network/plotter/utils/layout.py,sha256=OPqV8jzV9dpnOhYU4SYMSfsIXalVzESrlBSI_Y43OGU,3640
+risk/stats/__init__.py,sha256=2zdLv3tUHKyAjwAo7LprVXRaak1cHgrpYMVMSik6JM4,324
+risk/stats/significance.py,sha256=6cKv2xBQXWTHZ6HpNWIqlNfKKS5pG_BcCUdMM3r_zw4,7336
+risk/stats/stat_tests.py,sha256=qYn85VrNJeIlEptkEUoYsPco4BQ604CLJxXczgekXgc,11986
+risk/stats/permutation/__init__.py,sha256=OLmYLm2uj96hPsSaUs0vUqFYw6Thwch_aHtpL7L0ZFw,127
+risk/stats/permutation/permutation.py,sha256=BWjgdBpLVcHvmwHy0bmD4aJFccxifNBSrrCBPppyKf4,10569
+risk/stats/permutation/test_functions.py,sha256=D3XMPM8CasUNytWSRce22TI6KK6XulYn5uGG4lWxaHs,3120
+risk_network-0.0.9b28.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.9b28.dist-info/METADATA,sha256=v9uuUQ9EwyI5WzIirw_ONry2KPaiHqTiw2TDWX60Y6c,47627
+risk_network-0.0.9b28.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+risk_network-0.0.9b28.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.9b28.dist-info/RECORD,,

risk/stats/binom.py

@@ -1,51 +0,0 @@
-"""
-risk/stats/binomial
-~~~~~~~~~~~~~~~~~~~
-"""
-
-from typing import Any, Dict
-
-from scipy.sparse import csr_matrix
-from scipy.stats import binom
-
-
-def compute_binom_test(
-    neighborhoods: csr_matrix,
-    annotations: csr_matrix,
-    null_distribution: str = "network",
-) -> Dict[str, Any]:
-    """Compute Binomial test for enrichment and depletion in neighborhoods with selectable null distribution.
-
-    Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
-
-    Returns:
-        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
-    """
-    # Get the total number of nodes in the network
-    total_nodes = neighborhoods.shape[1]
-
-    # Compute sums (remain sparse here)
-    neighborhood_sizes = neighborhoods.sum(axis=1)  # Row sums
-    annotation_totals = annotations.sum(axis=0)  # Column sums
-    # Compute probabilities (convert to dense)
-    if null_distribution == "network":
-        p_values = (annotation_totals / total_nodes).A.flatten()  # Dense 1D array
-    elif null_distribution == "annotations":
-        p_values = (annotation_totals / annotations.sum()).A.flatten()  # Dense 1D array
-    else:
-        raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
-        )
-
-    # Observed counts (sparse matrix multiplication)
-    annotated_counts = neighborhoods @ annotations  # Sparse result
-    annotated_counts_dense = annotated_counts.toarray()  # Convert for dense operations
-
-    # Compute enrichment and depletion p-values
-    enrichment_pvals = 1 - binom.cdf(annotated_counts_dense - 1, neighborhood_sizes.A, p_values)
-    depletion_pvals = binom.cdf(annotated_counts_dense, neighborhood_sizes.A, p_values)
-
-    return {"enrichment_pvals": enrichment_pvals, "depletion_pvals": depletion_pvals}

risk/stats/chi2.py

@@ -1,69 +0,0 @@
-"""
-risk/stats/chi2
-~~~~~~~~~~~~~~~
-"""
-
-from typing import Any, Dict
-
-import numpy as np
-from scipy.sparse import csr_matrix
-from scipy.stats import chi2
-
-
-def compute_chi2_test(
-    neighborhoods: csr_matrix,
-    annotations: csr_matrix,
-    null_distribution: str = "network",
-) -> Dict[str, Any]:
-    """Compute chi-squared test for enrichment and depletion in neighborhoods with selectable null distribution.
-
-    Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
-
-    Returns:
-        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
-    """
-    # Total number of nodes in the network
-    total_node_count = neighborhoods.shape[0]
-
-    if null_distribution == "network":
-        # Case 1: Use all nodes as the background
-        background_population = total_node_count
-        neighborhood_sums = neighborhoods.sum(axis=0)  # Column sums of neighborhoods
-        annotation_sums = annotations.sum(axis=0)  # Column sums of annotations
-    elif null_distribution == "annotations":
-        # Case 2: Only consider nodes with at least one annotation
-        annotated_nodes = (
-            np.ravel(annotations.sum(axis=1)) > 0
-        )  # Row-wise sum to filter nodes with annotations
-        background_population = annotated_nodes.sum()  # Total number of annotated nodes
-        neighborhood_sums = neighborhoods[annotated_nodes].sum(
-            axis=0
-        )  # Neighborhood sums for annotated nodes
-        annotation_sums = annotations[annotated_nodes].sum(
-            axis=0
-        )  # Annotation sums for annotated nodes
-    else:
-        raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
-        )
-
-    # Convert to dense arrays for downstream computations
-    neighborhood_sums = np.asarray(neighborhood_sums).reshape(-1, 1)  # Ensure column vector shape
-    annotation_sums = np.asarray(annotation_sums).reshape(1, -1)  # Ensure row vector shape
-
-    # Observed values: number of annotated nodes in each neighborhood
-    observed = neighborhoods.T @ annotations  # Shape: (neighborhoods, annotations)
-    # Expected values under the null
-    expected = (neighborhood_sums @ annotation_sums) / background_population
-    # Chi-squared statistic: sum((observed - expected)^2 / expected)
-    with np.errstate(divide="ignore", invalid="ignore"):  # Handle divide-by-zero
-        chi2_stat = np.where(expected > 0, np.power(observed - expected, 2) / expected, 0)
-
-    # Compute p-values for enrichment (upper tail) and depletion (lower tail)
-    enrichment_pvals = chi2.sf(chi2_stat, df=1)  # Survival function for upper tail
-    depletion_pvals = chi2.cdf(chi2_stat, df=1)  # Cumulative distribution for lower tail
-
-    return {"depletion_pvals": depletion_pvals, "enrichment_pvals": enrichment_pvals}

risk/stats/hypergeom.py

@@ -1,64 +0,0 @@
-"""
-risk/stats/hypergeom
-~~~~~~~~~~~~~~~~~~~~
-"""
-
-from typing import Any, Dict
-
-import numpy as np
-from scipy.sparse import csr_matrix
-from scipy.stats import hypergeom
-
-
-def compute_hypergeom_test(
-    neighborhoods: csr_matrix,
-    annotations: csr_matrix,
-    null_distribution: str = "network",
-) -> Dict[str, Any]:
-    """
-    Compute hypergeometric test for enrichment and depletion in neighborhoods with selectable null distribution.
-
-    Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
-
-    Returns:
-        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
-    """
-    # Get the total number of nodes in the network
-    total_nodes = neighborhoods.shape[1]
-
-    # Compute sums
-    neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()  # Convert to dense array
-    annotation_sums = annotations.sum(axis=0).A.flatten()  # Convert to dense array
-
-    if null_distribution == "network":
-        background_population = total_nodes
-    elif null_distribution == "annotations":
-        annotated_nodes = annotations.sum(axis=1).A.flatten() > 0  # Boolean mask
-        background_population = annotated_nodes.sum()
-        neighborhood_sums = neighborhoods[annotated_nodes].sum(axis=0).A.flatten()
-        annotation_sums = annotations[annotated_nodes].sum(axis=0).A.flatten()
-    else:
-        raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
-        )
-
-    # Observed counts
-    annotated_in_neighborhood = neighborhoods.T @ annotations  # Sparse result
-    annotated_in_neighborhood = annotated_in_neighborhood.toarray()  # Convert to dense
-    # Align shapes for broadcasting
-    neighborhood_sums = neighborhood_sums.reshape(-1, 1)
-    annotation_sums = annotation_sums.reshape(1, -1)
-    background_population = np.array(background_population).reshape(1, 1)
-
-    # Compute hypergeometric p-values
-    depletion_pvals = hypergeom.cdf(
-        annotated_in_neighborhood, background_population, annotation_sums, neighborhood_sums
-    )
-    enrichment_pvals = hypergeom.sf(
-        annotated_in_neighborhood - 1, background_population, annotation_sums, neighborhood_sums
-    )
-
-    return {"depletion_pvals": depletion_pvals, "enrichment_pvals": enrichment_pvals}

risk/stats/poisson.py

@@ -1,50 +0,0 @@
-"""
-risk/stats/poisson
-~~~~~~~~~~~~~~~~~~
-"""
-
-from typing import Any, Dict
-
-import numpy as np
-from scipy.sparse import csr_matrix
-from scipy.stats import poisson
-
-
-def compute_poisson_test(
-    neighborhoods: csr_matrix,
-    annotations: csr_matrix,
-    null_distribution: str = "network",
-) -> Dict[str, Any]:
-    """
-    Compute Poisson test for enrichment and depletion in neighborhoods with selectable null distribution.
-
-    Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
-
-    Returns:
-        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
-    """
-    # Matrix multiplication to get the number of annotated nodes in each neighborhood
-    annotated_in_neighborhood = neighborhoods @ annotations  # Sparse result
-    # Convert annotated counts to dense for downstream calculations
-    annotated_in_neighborhood_dense = annotated_in_neighborhood.toarray()
-
-    # Compute lambda_expected based on the chosen null distribution
-    if null_distribution == "network":
-        # Use the mean across neighborhoods (axis=1)
-        lambda_expected = np.mean(annotated_in_neighborhood_dense, axis=1, keepdims=True)
-    elif null_distribution == "annotations":
-        # Use the mean across annotations (axis=0)
-        lambda_expected = np.mean(annotated_in_neighborhood_dense, axis=0, keepdims=True)
-    else:
-        raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
-        )
-
-    # Compute p-values for enrichment and depletion using Poisson distribution
-    enrichment_pvals = 1 - poisson.cdf(annotated_in_neighborhood_dense - 1, lambda_expected)
-    depletion_pvals = poisson.cdf(annotated_in_neighborhood_dense, lambda_expected)
-
-    return {"enrichment_pvals": enrichment_pvals, "depletion_pvals": depletion_pvals}

risk/stats/zscore.py

@@ -1,68 +0,0 @@
-"""
-risk/stats/zscore
-~~~~~~~~~~~~~~~~~~
-"""
-
-from typing import Any, Dict
-
-import numpy as np
-from scipy.sparse import csr_matrix
-from scipy.stats import norm
-
-
-def compute_zscore_test(
-    neighborhoods: csr_matrix,
-    annotations: csr_matrix,
-    null_distribution: str = "network",
-) -> Dict[str, Any]:
-    """
-    Compute Z-score test for enrichment and depletion in neighborhoods with selectable null distribution.
-
-    Args:
-        neighborhoods (csr_matrix): Sparse binary matrix representing neighborhoods.
-        annotations (csr_matrix): Sparse binary matrix representing annotations.
-        null_distribution (str, optional): Type of null distribution ('network' or 'annotations'). Defaults to "network".
-
-    Returns:
-        Dict[str, Any]: Dictionary containing depletion and enrichment p-values.
-    """
-    # Total number of nodes in the network
-    total_node_count = neighborhoods.shape[1]
-
-    # Compute sums
-    if null_distribution == "network":
-        background_population = total_node_count
-        neighborhood_sums = neighborhoods.sum(axis=0).A.flatten()  # Dense column sums
-        annotation_sums = annotations.sum(axis=0).A.flatten()  # Dense row sums
-    elif null_distribution == "annotations":
-        annotated_nodes = annotations.sum(axis=1).A.flatten() > 0  # Dense boolean mask
-        background_population = annotated_nodes.sum()
-        neighborhood_sums = neighborhoods[annotated_nodes].sum(axis=0).A.flatten()
-        annotation_sums = annotations[annotated_nodes].sum(axis=0).A.flatten()
-    else:
-        raise ValueError(
-            "Invalid null_distribution value. Choose either 'network' or 'annotations'."
-        )
-
-    # Observed values
-    observed = (neighborhoods.T @ annotations).toarray()  # Convert sparse result to dense
-    # Expected values under the null
-    neighborhood_sums = neighborhood_sums.reshape(-1, 1)  # Ensure correct shape
-    annotation_sums = annotation_sums.reshape(1, -1)  # Ensure correct shape
-    expected = (neighborhood_sums @ annotation_sums) / background_population
-
-    # Standard deviation under the null
-    std_dev = np.sqrt(
-        expected
-        * (1 - annotation_sums / background_population)
-        * (1 - neighborhood_sums / background_population)
-    )
-    std_dev[std_dev == 0] = np.nan  # Avoid division by zero
-    # Compute Z-scores
-    z_scores = (observed - expected) / std_dev
-
-    # Convert Z-scores to depletion and enrichment p-values
-    enrichment_pvals = norm.sf(z_scores)  # Upper tail
-    depletion_pvals = norm.cdf(z_scores)  # Lower tail
-
-    return {"depletion_pvals": depletion_pvals, "enrichment_pvals": enrichment_pvals}