cytocommunity2 0.1.3__tar.gz → 0.1.4__tar.gz

{cytocommunity2-0.1.3/src/cytocommunity2.egg-info → cytocommunity2-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cytocommunity2
-Version: 0.1.3
+Version: 0.1.4
 Summary: Weakly supervised cellular-neighborhood learning for spatial omics
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -10,7 +10,7 @@ Requires-Dist: numpy<2,>=1.23
 Requires-Dist: pandas<3,>=1.5
 Requires-Dist: sci-palettes
 Requires-Dist: scikit-learn>=1.1
-Requires-Dist: scipy>=1.9
+Requires-Dist: scipy>=1.11
 Requires-Dist: seaborn>=0.12
 Requires-Dist: torch-geometric>=2.0
 Provides-Extra: downstream

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cytocommunity2"
-version = "0.1.3"
+version = "0.1.4"
 description = "Weakly supervised cellular-neighborhood learning for spatial omics"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -14,7 +14,7 @@ dependencies = [
     "pandas>=1.5,<3",
     "sci-palettes",
     "scikit-learn>=1.1",
-    "scipy>=1.9",
+    "scipy>=1.11",
     "seaborn>=0.12",
     "torch-geometric>=2.0",
 ]

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4}/src/cytocommunity2/__init__.py

@@ -2,22 +2,22 @@
 
 from .config import CytoCommunityConfig
 from .learning import (
-    LearningResult,
-    SpatialGraphDataset,
-    build_spatial_graphs,
-    load_learning_result,
-    run_learning,
+    LearningResult,
+    SpatialGraphDataset,
+    build_spatial_graphs,
+    load_learning_result,
+    run_learning,
 )
 from .visualization import visualize_results
 
-__version__ = "0.1.1"
+__version__ = "0.1.4"
 
 __all__ = [
     "CytoCommunityConfig",
     "LearningResult",
     "SpatialGraphDataset",
-    "build_spatial_graphs",
-    "load_learning_result",
-    "run_learning",
+    "build_spatial_graphs",
+    "load_learning_result",
+    "run_learning",
     "visualize_results",
 ]

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4}/src/cytocommunity2/config.py

@@ -8,7 +8,6 @@ from typing import Any, Mapping
 
 
 DEFAULT_CONFIG_FILE = "hyperparameters.json"
-INPUT_DIR_NAME = "TNBC_Input_pCR"
 
 # Established analysis rules stay stable across runs; only experimental choices
 # belong in hyperparameters.json.
@@ -94,13 +93,15 @@ def _require_keys(values, required, section):
 
 
 def _load_config(config_file=None, config_class=CytoCommunityConfig):
-    """Load one configuration file and use the adjacent TNBC input folder."""
-    config_file = Path(config_file or DEFAULT_CONFIG_FILE).expanduser().resolve()
-    raw = json.loads(config_file.read_text(encoding="utf-8"))
-    _require_keys(raw, ["random_seed", "main", "downstream"], "root")
+    """Load one configuration file and resolve its configured input folder."""
+    config_file = Path(config_file or DEFAULT_CONFIG_FILE).expanduser().resolve()
+    raw = json.loads(config_file.read_text(encoding="utf-8"))
+    _require_keys(raw, ["input_dir", "random_seed", "main", "downstream"], "root")
 
     project_root = config_file.parent
-    input_dir = project_root / INPUT_DIR_NAME
+    input_dir = Path(raw["input_dir"]).expanduser()
+    if not input_dir.is_absolute():
+        input_dir = project_root / input_dir
 
     main = MainConfig(**raw["main"])
     enrichment = EnrichmentConfig()

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4}/src/cytocommunity2/downstream/plotting/recurrence.py

@@ -62,7 +62,7 @@ def plot_recurrence_results(config):
     output_dir.mkdir(parents=True, exist_ok=True)
     real = pd.read_csv(overlap_dir / "RealDistribution_sameCN.csv")
     background = pd.read_csv(overlap_dir / "BackgroundDistribution_randomCN.csv")
-    tests = pd.read_csv(overlap_dir / "TTest_Results.csv")
+    tests = pd.read_csv(overlap_dir / "KSTest_Results.csv")
     real["CN"] = real["CN"].astype(str).str.strip()
     real["OverlapCoefficient"] = pd.to_numeric(real["OverlapCoefficient"], errors="coerce")
     background["OverlapCoefficient"] = pd.to_numeric(

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4}/src/cytocommunity2/learning/api.py

@@ -3,9 +3,10 @@
 import datetime
 from dataclasses import dataclass
 from pathlib import Path
-import shutil
-
-import pandas as pd
+import shutil
+
+import numpy as np
+import pandas as pd
 
 from ..config import CytoCommunityConfig
 from ..ensemble import ensemble_cn
@@ -133,7 +134,11 @@ def run_learning(
             collect_hard_assignments=True,
         )
 
-        result, cn_pvalues = evaluate_cn_num(
+        cn_labels_by_sample = {
+            sample: hard_assignments[sample_index]
+            for sample_index, sample in enumerate(dataset.sample_names)
+        }
+        result, cn_pvalues = evaluate_cn_num(
             num_cn=num_cn,
             dataset=input_dir,
             celltype_file=unique_celltypes_file,
@@ -143,30 +148,35 @@ def run_learning(
             recurrence_p_threshold=config.recurrence.recurrence_p_threshold,
             n_random=config.recurrence.null_draws,
             seed=config.random_seed,
-            hard_assignments=hard_assignments,
-        )
-        del hard_assignments
+            cn_labels_by_sample=cn_labels_by_sample,
+        )
+        del hard_assignments, cn_labels_by_sample
         selection_results.append(result)
-        cn_pvalues = cn_pvalues[
-            [
-                "CN",
-                "p_value_one_sided",
-                "p_adjusted_bh",
-                "RecurrenceScore",
+        cn_pvalues = cn_pvalues[
+            [
+                "CN",
+                "n_real",
+                "n_background",
+                "real_mean",
+                "background_mean",
+                "delta_mean",
+                "KSStatistic",
+                "KSLocation",
+                "p_value_one_sided",
+                "p_adjusted_bh",
+                "RecurrenceScore",
                 "SignificantRecurrence",
             ]
         ].copy()
         cn_pvalues.insert(0, "NumCN", num_cn)
-        cn_pvalue_tables.append(cn_pvalues)
-        print(
-            f"K={num_cn}: significantCN={result['SignificantCN']}, "
-            f"significantFraction={result['SignificantFraction']:.6f}, "
-            f"meanRS={result['MeanRS']:.6f}, score={result['Score']:.6f}"
+        cn_pvalue_tables.append(cn_pvalues)
+        print(
+            f"K={num_cn}: Ksig={result['Ksig']}, "
+            f"significantFraction={result['SignificantFraction']:.6f}, "
+            f"MeanRS={result['MeanRS']:.6f}, CRI={result['CRI']:.6f}"
         )
 
-    pd.DataFrame(selection_results).sort_values("NumCN").to_csv(
-        selection_summary_file, index=False
-    )
+    pd.DataFrame(selection_results).to_csv(selection_summary_file, index=False)
     pd.concat(cn_pvalue_tables, ignore_index=True).to_csv(
         cn_pvalues_file, index=False
     )
@@ -175,9 +185,9 @@ def run_learning(
     (output_dir / "SelectedCNNum.txt").write_text(
         f"{selected_cn}\n", encoding="utf-8"
     )
-    print(
-        f"\nSelected K={selected_cn} with score={selected['Score']:.6f}. "
-        f"Training a fresh set of Runs 1-{config.main.final_num_runs}."
+    print(
+        f"\nSelected K={selected_cn} with CRI={selected['CRI']:.6f}. "
+        f"Training a fresh set of Runs 1-{config.main.final_num_runs}."
     )
 
     selected_config = _training_config(
@@ -185,22 +195,32 @@ def run_learning(
     )
     for run_index in range(1, config.main.final_num_runs + 1):
         print(f"\n=== Selected K={selected_cn}: Run {run_index} ===")
-        train_one_run(
-            dataset,
-            selected_config,
-            run_index=run_index,
-            output_folder=selected_model_dir / f"Run{run_index}",
-            dynamic_pseudo=dataset.dynamic_pseudo,
-            base_seed=config.random_seed,
-            save_soft_assignments=True,
-            collect_hard_assignments=False,
-        )
-
-    ensemble_cn(
-        input_dir=input_dir,
-        selected_model_dir=selected_model_dir,
-        hard_assignment_dir=hard_assignment_dir,
-    )
+        _, hard_assignments = train_one_run(
+            dataset,
+            selected_config,
+            run_index=run_index,
+            output_folder=selected_model_dir / f"Run{run_index}",
+            dynamic_pseudo=dataset.dynamic_pseudo,
+            base_seed=config.random_seed,
+            save_soft_assignments=True,
+            collect_hard_assignments=config.main.final_num_runs == 1,
+        )
+
+    if config.main.final_num_runs == 1:
+        hard_assignment_dir.mkdir()
+        for sample_index, sample in enumerate(dataset.sample_names):
+            np.savetxt(
+                hard_assignment_dir / f"{sample}_CNLabel_MajorityVoting.csv",
+                hard_assignments[sample_index],
+                delimiter=",",
+                fmt="%d",
+            )
+    else:
+        ensemble_cn(
+            input_dir=input_dir,
+            selected_model_dir=selected_model_dir,
+            hard_assignment_dir=hard_assignment_dir,
+        )
     return LearningResult(
         selected_cn=selected_cn,
         dataset=dataset,

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4}/src/cytocommunity2/learning/selection.py

@@ -5,15 +5,12 @@ from pathlib import Path
 
 import numpy as np
 import pandas as pd
-from scipy.stats import hypergeom, ttest_ind
+from scipy.stats import false_discovery_control, hypergeom, ks_2samp
 
 from ..paths import build_paths
 
 
-MIN_FLOAT_P = np.finfo(np.float64).tiny
-
-
-def read_nonempty_lines(path):
+def read_nonempty_lines(path):
     values = [
         line.strip()
         for line in Path(path).read_text(encoding="utf-8-sig").splitlines()
@@ -24,42 +21,14 @@ def read_nonempty_lines(path):
     return values
 
 
-def _bh_adjust_matlab(pvalues):
-    pvalues = np.asarray(pvalues, dtype=np.float64)
-    flat = pvalues.ravel(order="F")
-    order = np.argsort(flat, kind="stable")
-    sorted_p = flat[order]
-    weighted = sorted_p.size * sorted_p / np.arange(1, sorted_p.size + 1)
-    adjusted_sorted = np.minimum.accumulate(weighted[::-1])[::-1]
-    adjusted = np.empty_like(flat)
-    adjusted[order] = adjusted_sorted
-    return adjusted.reshape(pvalues.shape, order="F")
-
-
-def bh_adjust(pvalues):
-    """Benjamini-Hochberg adjustment for one family of CN hypotheses."""
-    pvalues = np.asarray(pvalues, dtype=np.float64)
-    clean_pvalues = np.where(np.isfinite(pvalues), pvalues, 1.0)
-    clean_pvalues = np.clip(clean_pvalues, 0.0, 1.0)
-    order = np.argsort(clean_pvalues, kind="stable")
-    sorted_pvalues = clean_pvalues[order]
-    ranks = np.arange(1, sorted_pvalues.size + 1, dtype=np.float64)
-    adjusted_sorted = np.minimum.accumulate(
-        (sorted_pvalues.size * sorted_pvalues / ranks)[::-1]
-    )[::-1]
-    adjusted = np.empty_like(clean_pvalues)
-    adjusted[order] = np.clip(adjusted_sorted, 0.0, 1.0)
-    return adjusted
-
-
-def calculate_enrichment_matrix(
+def calculate_enrichment_matrix(
     cell_labels,
     cn_labels,
     cell_types,
     num_cn,
     minimum_adjusted_p,
 ):
-    """Reproduce CellTypeEnrichmentMatrix.m, including its tail precision."""
+    """Calculate BH-adjusted cell-type enrichment scores for one sample."""
     cell_labels = np.asarray(cell_labels, dtype=str)
     cn_labels = np.asarray(cn_labels, dtype=np.int64)
     if cell_labels.ndim != 1 or cn_labels.ndim != 1:
@@ -98,70 +67,47 @@ def calculate_enrichment_matrix(
                     int(cell_type_totals[cell_type_index]),
                     int(cn_totals[cn_index]),
                 )
-                raw_pvalues[cell_type_index, cn_index] = 1.0 - (1.0 - upper_tail)
+                raw_pvalues[cell_type_index, cn_index] = upper_tail
 
-    adjusted = _bh_adjust_matlab(raw_pvalues)
+    adjusted = false_discovery_control(
+        raw_pvalues.ravel(order="F"), method="bh"
+    ).reshape(raw_pvalues.shape, order="F")
     adjusted[adjusted < minimum_adjusted_p] = minimum_adjusted_p
     return -np.log10(adjusted)
 
 
-def calculate_enrichment(
-    dataset,
-    celltype_file,
-    output_dir,
-    num_cn,
-    minimum_adjusted_p,
-    cn_label_dir=None,
-    hard_assignments=None,
-):
-    dataset = Path(dataset)
-    if (cn_label_dir is None) == (hard_assignments is None):
-        raise ValueError(
-            "Provide exactly one of cn_label_dir or hard_assignments"
-        )
-    if cn_label_dir is not None:
-        cn_label_dir = Path(cn_label_dir)
-    output_dir = Path(output_dir)
-    samples = read_nonempty_lines(dataset / "ImageNameList.txt")
-    cell_types = read_nonempty_lines(celltype_file)
-    output_dir.mkdir(parents=True, exist_ok=True)
-    pd.DataFrame({"Var1": cell_types}).to_csv(
-        output_dir / "CellTypeVec_List.csv", index=False
-    )
-
-    rows = []
-    for sample_index, sample in enumerate(samples):
-        cell_labels = (
-            pd.read_csv(
-                dataset / f"{sample}_CellTypeLabel.txt",
+def calculate_enrichment(
+    dataset,
+    cell_types,
+    cn_labels_by_sample,
+    output_dir,
+    num_cn,
+    minimum_adjusted_p,
+):
+    dataset = Path(dataset)
+    output_dir = Path(output_dir)
+    samples = read_nonempty_lines(dataset / "ImageNameList.txt")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame({"Var1": cell_types}).to_csv(
+        output_dir / "CellTypeVec_List.csv", index=False
+    )
+
+    matrices = {}
+    for sample in samples:
+        cell_labels = (
+            pd.read_csv(
+                dataset / f"{sample}_CellTypeLabel.txt",
                 sep="\t",
                 header=None,
                 dtype=str,
             )
-            .iloc[:, 0]
-            .to_numpy()
-        )
-        if hard_assignments is not None:
-            if sample_index not in hard_assignments:
-                raise KeyError(
-                    f"Missing in-memory CN labels for sample index {sample_index}"
-                )
-            cn_labels = np.asarray(
-                hard_assignments[sample_index], dtype=np.int64
-            )
-        else:
-            cn_labels = (
-                pd.read_csv(
-                    cn_label_dir / f"{sample}_CNLabel_MajorityVoting.csv",
-                    header=None,
-                    dtype=np.int64,
-                )
-                .iloc[:, 0]
-                .to_numpy()
-            )
-        matrix = calculate_enrichment_matrix(
-            cell_labels,
-            cn_labels,
+            .iloc[:, 0]
+            .to_numpy()
+        )
+        cn_labels = np.asarray(cn_labels_by_sample[sample], dtype=np.int64)
+        matrix = calculate_enrichment_matrix(
+            cell_labels,
+            cn_labels,
             cell_types,
             num_cn,
             minimum_adjusted_p,
@@ -169,11 +115,25 @@ def calculate_enrichment(
         np.savetxt(
             output_dir / f"{sample}_EnrichScoreMatrix.csv",
             matrix,
-            delimiter=",",
-            fmt="%.15g",
-        )
-        rows.append({"Sample": sample, "Cells": len(cell_labels), "NumCN": num_cn})
-    return pd.DataFrame(rows)
+            delimiter=",",
+            fmt="%.15g",
+        )
+        matrices[sample] = matrix
+    return matrices
+
+
+def _load_cn_labels(samples, cn_label_dir):
+    cn_label_dir = Path(cn_label_dir)
+    return {
+        sample: pd.read_csv(
+            cn_label_dir / f"{sample}_CNLabel_MajorityVoting.csv",
+            header=None,
+            dtype=np.int64,
+        )
+        .iloc[:, 0]
+        .to_numpy()
+        for sample in samples
+    }
 
 
 def export_enrichment_long(dataset, enrichment_dir, output_file):
@@ -223,82 +183,51 @@ def overlap_coefficient(first, second):
     return len(first & second) / smaller_size if smaller_size else 0.0
 
 
-def _load_dominant_sets(samples, score_dir, score_threshold):
-    celltypes = (
-        pd.read_csv(Path(score_dir) / "CellTypeVec_List.csv")
-        .iloc[:, 0]
-        .astype(str)
-        .to_numpy()
-    )
-    dominant_sets = {}
-    num_cn = None
-    for sample in samples:
-        matrix = pd.read_csv(
-            Path(score_dir) / f"{sample}_EnrichScoreMatrix.csv", header=None
-        ).to_numpy(dtype=float)
-        if matrix.shape[0] != len(celltypes):
-            raise ValueError(f"{sample}: enrichment matrix has the wrong row count")
-        if num_cn is None:
-            num_cn = matrix.shape[1]
-        elif matrix.shape[1] != num_cn:
-            raise ValueError(f"{sample}: inconsistent number of CN columns")
-        dominant_sets[sample] = [
-            set(celltypes[matrix[:, cn] > score_threshold])
-            for cn in range(matrix.shape[1])
-        ]
-    return dominant_sets, num_cn
-
-
-def _summarize_ttest(cn, real_values, background_values):
-    real_values = np.asarray(real_values, dtype=float)
-    background_values = np.asarray(background_values, dtype=float)
-    if len(real_values) >= 2 and len(background_values) >= 2:
-        result = ttest_ind(
-            real_values,
-            background_values,
-            equal_var=False,
-            alternative="greater",
-        )
-        t_statistic, p_value = float(result.statistic), float(result.pvalue)
-    else:
-        t_statistic, p_value = np.nan, np.nan
-    real_mean = np.mean(real_values) if len(real_values) else np.nan
-    background_mean = (
-        np.mean(background_values) if len(background_values) else np.nan
-    )
-    return {
-        "CN": cn,
-        "n_real": len(real_values),
-        "n_background": len(background_values),
-        "real_mean": real_mean,
-        "real_std": np.std(real_values, ddof=1) if len(real_values) > 1 else np.nan,
-        "background_mean": background_mean,
-        "background_std": (
-            np.std(background_values, ddof=1)
-            if len(background_values) > 1
-            else np.nan
-        ),
-        "delta_mean": real_mean - background_mean,
-        "t_statistic": t_statistic,
-        "p_value_one_sided": p_value,
+def _summarize_ks(cn, real_values, background_values):
+    real_values = np.asarray(real_values, dtype=float)
+    background_values = np.asarray(background_values, dtype=float)
+    result = ks_2samp(
+        real_values,
+        background_values,
+        alternative="less",
+        method="asymp",
+    )
+    real_mean = float(np.mean(real_values))
+    background_mean = float(np.mean(background_values))
+    return {
+        "CN": cn,
+        "n_real": len(real_values),
+        "n_background": len(background_values),
+        "real_mean": real_mean,
+        "background_mean": background_mean,
+        "delta_mean": real_mean - background_mean,
+        "KSStatistic": float(result.statistic),
+        "KSLocation": float(result.statistic_location),
+        "p_value_one_sided": float(result.pvalue),
     }
 
 
-def calculate_recurrence(
-    score_dir,
-    image_list_file,
-    output_dir,
+def calculate_recurrence(
+    enrichment_matrices,
+    cell_types,
+    output_dir,
     score_threshold,
     recurrence_p_threshold,
-    n_random,
-    seed,
-):
-    samples = read_nonempty_lines(image_list_file)
-    if len(samples) < 2:
-        raise ValueError("At least two samples are required for recurrence analysis")
-    dominant_sets, num_cn = _load_dominant_sets(
-        samples, score_dir, score_threshold
-    )
+    n_random,
+    seed,
+):
+    samples = list(enrichment_matrices)
+    if len(samples) < 2:
+        raise ValueError("At least two samples are required for recurrence analysis")
+    cell_types = np.asarray(cell_types, dtype=str)
+    num_cn = enrichment_matrices[samples[0]].shape[1]
+    dominant_sets = {
+        sample: [
+            set(cell_types[matrix[:, cn] > score_threshold])
+            for cn in range(num_cn)
+        ]
+        for sample, matrix in enrichment_matrices.items()
+    }
     sample_pairs = list(combinations(samples, 2))
     real_df = pd.DataFrame(
         [
@@ -324,35 +253,20 @@ def calculate_recurrence(
         )
     background_df = pd.DataFrame({"OverlapCoefficient": background_values})
 
-    ttest_rows = []
+    ks_rows = []
     for cn in [f"CN{index + 1}" for index in range(num_cn)]:
         values = real_df.loc[
             real_df["CN"] == cn, "OverlapCoefficient"
         ].to_numpy()
-        ttest_rows.append(_summarize_ttest(cn, values, background_values))
-    ttest_rows.append(
-        _summarize_ttest(
-            "Overall", real_df["OverlapCoefficient"].to_numpy(), background_values
-        )
-    )
-    ttest_df = pd.DataFrame(ttest_rows)
-    cn_mask = ttest_df["CN"] != "Overall"
-    adjusted_pvalues = bh_adjust(
-        ttest_df.loc[cn_mask, "p_value_one_sided"].to_numpy()
-    )
-    ttest_df["p_adjusted_bh"] = np.nan
-    ttest_df["RecurrenceScore"] = np.nan
-    ttest_df["SignificantRecurrence"] = False
-    ttest_df.loc[cn_mask, "p_adjusted_bh"] = adjusted_pvalues
-    ttest_df.loc[cn_mask, "RecurrenceScore"] = -np.log10(
-        np.maximum(adjusted_pvalues, MIN_FLOAT_P)
-    )
-    ttest_df.loc[cn_mask, "SignificantRecurrence"] = (
-        (
-            ttest_df.loc[cn_mask, "p_adjusted_bh"]
-            < recurrence_p_threshold
-        )
-        & (ttest_df.loc[cn_mask, "delta_mean"] > 0)
+        ks_rows.append(_summarize_ks(cn, values, background_values))
+    ks_df = pd.DataFrame(ks_rows)
+    ks_df["p_adjusted_bh"] = false_discovery_control(
+        ks_df["p_value_one_sided"].to_numpy(), method="bh"
+    )
+    ks_df["RecurrenceScore"] = ks_df["KSStatistic"] * 100.0
+    ks_df["SignificantRecurrence"] = (
+        (ks_df["p_adjusted_bh"] < recurrence_p_threshold)
+        & (ks_df["delta_mean"] > 0)
     )
 
     output_dir = Path(output_dir)
@@ -361,73 +275,72 @@ def calculate_recurrence(
     background_df.to_csv(
         output_dir / "BackgroundDistribution_randomCN.csv", index=False
     )
-    ttest_df.to_csv(output_dir / "TTest_Results.csv", index=False)
-    return real_df, background_df, ttest_df
+    ks_df.to_csv(output_dir / "KSTest_Results.csv", index=False)
+    return real_df, background_df, ks_df
 
 
-def evaluate_cn_num(
+def evaluate_cn_num(
     num_cn,
     dataset,
     celltype_file,
     output_dir,
     enrichment_p_threshold,
     minimum_adjusted_p,
-    recurrence_p_threshold,
-    n_random,
-    seed,
-    cn_label_dir=None,
-    hard_assignments=None,
-):
+    recurrence_p_threshold,
+    n_random,
+    seed,
+    cn_labels_by_sample,
+):
     """Calculate the recurrence-weighted CN resolution index and per-CN tests."""
     output_dir = Path(output_dir)
     enrichment_dir = output_dir / "EnrichScoreMatrix"
     overlap_dir = output_dir / "OverlapCoefficient"
-    calculate_enrichment(
-        dataset=dataset,
-        celltype_file=celltype_file,
-        output_dir=enrichment_dir,
-        num_cn=num_cn,
-        minimum_adjusted_p=minimum_adjusted_p,
-        cn_label_dir=cn_label_dir,
-        hard_assignments=hard_assignments,
-    )
-    real_df, _, ttest_df = calculate_recurrence(
-        enrichment_dir,
-        Path(dataset) / "ImageNameList.txt",
-        overlap_dir,
-        score_threshold=-np.log10(enrichment_p_threshold),
+    cell_types = read_nonempty_lines(celltype_file)
+    enrichment_matrices = calculate_enrichment(
+        dataset=dataset,
+        cell_types=cell_types,
+        cn_labels_by_sample=cn_labels_by_sample,
+        output_dir=enrichment_dir,
+        num_cn=num_cn,
+        minimum_adjusted_p=minimum_adjusted_p,
+    )
+    real_df, _, per_cn = calculate_recurrence(
+        enrichment_matrices=enrichment_matrices,
+        cell_types=cell_types,
+        output_dir=overlap_dir,
+        score_threshold=-np.log10(enrichment_p_threshold),
         recurrence_p_threshold=recurrence_p_threshold,
         n_random=n_random,
         seed=seed,
     )
-    per_cn = ttest_df[ttest_df["CN"] != "Overall"]
-    significant_mask = per_cn["SignificantRecurrence"].astype(bool)
+    significant_mask = per_cn["SignificantRecurrence"].astype(bool)
     significant_cn = int(significant_mask.sum())
     significant_fraction = significant_cn / num_cn
     mean_rs = float(per_cn["RecurrenceScore"].mean())
     mean_oc = float(real_df["OverlapCoefficient"].mean())
-    score = float(
-        significant_fraction**2 * significant_cn * mean_rs
-    )
-    result = {
-        "NumCN": int(num_cn),
-        "SignificantCN": significant_cn,
-        "SignificantFraction": significant_fraction,
-        "MeanRS": mean_rs,
-        "MeanOC": mean_oc,
-        "Score": score,
+    cri = float(significant_fraction**2 * mean_rs)
+    result = {
+        "NumCN": int(num_cn),
+        "Ksig": significant_cn,
+        "SignificantFraction": significant_fraction,
+        "MeanOC": mean_oc,
+        "MeanRS": mean_rs,
+        "CRI": cri,
     }
     pd.DataFrame([result]).to_csv(output_dir / "CNNumScore.csv", index=False)
-    return result, per_cn.copy()
+    return result, per_cn
 
 
 def evaluate_selected_cn(result, config):
     """Evaluate the selected model using the configured project layout."""
     paths = build_paths(config)
+    cn_labels_by_sample = _load_cn_labels(
+        result.dataset.sample_names, result.hard_assignment_dir
+    )
     metrics, recurrence = evaluate_cn_num(
         num_cn=result.selected_cn,
         dataset=result.input_dir,
-        cn_label_dir=result.hard_assignment_dir,
+        cn_labels_by_sample=cn_labels_by_sample,
         celltype_file=result.unique_celltypes_file,
         output_dir=paths.downstream_data,
         enrichment_p_threshold=config.enrichment.p_value_threshold,
@@ -445,7 +358,7 @@ def evaluate_selected_cn(result, config):
 
 
 def select_cn_num(results):
-    """Select maximum score, using smaller K as the deterministic tie-break."""
-    if not results:
-        raise ValueError("No CN-number results were supplied")
-    return min(results, key=lambda row: (-row["Score"], row["NumCN"]))
+    """Select maximum CRI, using smaller K as the deterministic tie-break."""
+    if not results:
+        raise ValueError("No CN-number results were supplied")
+    return min(results, key=lambda row: (-row["CRI"], row["NumCN"]))

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4}/src/cytocommunity2/learning/training.py

@@ -212,14 +212,19 @@ def train_one_run(
             _, _, _, assignment_logits, _ = model(
                 data.x, data.edge_index, data.batch
             )
-        if collect_hard_assignments:
-            hard_assignments[index] = (
-                torch.argmax(assignment_logits, dim=-1).cpu().numpy() + 1
-            )
-        if save_soft_assignments:
-            np.savetxt(
-                output_folder / f"ClusterAssignMatrix1_{index}.csv",
-                torch.softmax(assignment_logits, dim=-1).cpu().numpy(),
-                delimiter=",",
-            )
+        if save_soft_assignments:
+            soft_assignments = torch.softmax(
+                assignment_logits, dim=-1
+            ).cpu().numpy()
+            np.savetxt(
+                output_folder / f"ClusterAssignMatrix1_{index}.csv",
+                soft_assignments,
+                delimiter=",",
+            )
+        if collect_hard_assignments:
+            hard_assignments[index] = (
+                np.argmax(soft_assignments, axis=-1) + 1
+                if save_soft_assignments
+                else torch.argmax(assignment_logits, dim=-1).cpu().numpy() + 1
+            )
     return summary, hard_assignments

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4/src/cytocommunity2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cytocommunity2
-Version: 0.1.3
+Version: 0.1.4
 Summary: Weakly supervised cellular-neighborhood learning for spatial omics
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -10,7 +10,7 @@ Requires-Dist: numpy<2,>=1.23
 Requires-Dist: pandas<3,>=1.5
 Requires-Dist: sci-palettes
 Requires-Dist: scikit-learn>=1.1
-Requires-Dist: scipy>=1.9
+Requires-Dist: scipy>=1.11
 Requires-Dist: seaborn>=0.12
 Requires-Dist: torch-geometric>=2.0
 Provides-Extra: downstream

{cytocommunity2-0.1.3 → cytocommunity2-0.1.4}/src/cytocommunity2.egg-info/requires.txt

@@ -3,7 +3,7 @@ numpy<2,>=1.23
 pandas<3,>=1.5
 sci-palettes
 scikit-learn>=1.1
-scipy>=1.9
+scipy>=1.11
 seaborn>=0.12
 torch-geometric>=2.0