pythonflex 0.3.4__py3-none-any.whl → 0.4__py3-none-any.whl

pythonflex/examples/runtime/runtime_benchmark_corum_njobs.py

@@ -0,0 +1,245 @@
+"""Compare CORUM per-complex runtime with different n_jobs values.
+
+Run from any directory with:
+    python path/to/src/pythonflex/examples/runtime_benchmark_corum_njobs.py
+"""
+
+from __future__ import annotations
+
+import gc
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from time import perf_counter
+from typing import Any, Callable
+
+import pandas as pd
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[3]
+SRC_ROOT = PROJECT_ROOT / "src"
+if str(SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(SRC_ROOT))
+
+os.environ.setdefault("MPLBACKEND", "Agg")
+
+import pythonflex as flex  # noqa: E402
+
+
+GENE_EFFECT_PATH = Path(
+    "C:/Users/yd/Desktop/projects/_datasets/depmap/25Q2/gene_effect.csv"
+)
+CORR_FUNCTION = "numpy_without_mask"
+CHUNK_SIZE = 200
+MAX_NBYTES = "100M"
+N_JOBS_VALUES = (2, 4, 8)
+BENCHMARK_ROOT = (
+    PROJECT_ROOT
+    / "output"
+    / f"runtime_benchmark_corum_corr_reuse_njobs_{datetime.now():%Y%m%d_%H%M%S}"
+)
+
+
+def build_config(output_folder: Path, n_jobs: int) -> dict[str, Any]:
+    return {
+        "min_genes_in_complex": 2,
+        "min_genes_per_complex_analysis": 3,
+        "output_folder": str(output_folder),
+        "gold_standard": "CORUM",
+        "color_map": "RdYlBu",
+        "jaccard": True,
+        "analysis_genes": "common",
+        "plotting": {
+            "save_plot": True,
+            "show_plot": False,
+            "output_type": "png",
+        },
+        "preprocessing": {
+            "fill_na": True,
+            "normalize": False,
+        },
+        "corr_function": CORR_FUNCTION,
+        "per_complex": {
+            "n_jobs": n_jobs,
+            "chunk_size": CHUNK_SIZE,
+            "max_nbytes": MAX_NBYTES,
+        },
+        "logging": {
+            "visible_levels": ["DONE", "INFO", "WARNING"],
+        },
+    }
+
+
+def timed_call(
+    timings: list[dict[str, Any]],
+    n_jobs: int,
+    step: str,
+    operation: Callable[[], Any],
+    *,
+    is_corr: bool | None = None,
+) -> Any:
+    start = perf_counter()
+    result = operation()
+    timings.append(
+        {
+            "n_jobs": n_jobs,
+            "step": step,
+            "seconds": perf_counter() - start,
+            "chunk_size": CHUNK_SIZE,
+            "corr_function": CORR_FUNCTION,
+            "is_corr": is_corr,
+        }
+    )
+    return result
+
+
+def run_n_jobs(n_jobs: int) -> list[dict[str, Any]]:
+    output_folder = BENCHMARK_ROOT / f"n_jobs_{n_jobs:02d}"
+    timings: list[dict[str, Any]] = []
+    workflow_start = perf_counter()
+
+    timed_call(
+        timings,
+        n_jobs,
+        "initialize",
+        lambda: flex.initialize(build_config(output_folder, n_jobs)),
+    )
+    gene_effect = timed_call(
+        timings,
+        n_jobs,
+        "read_gene_effect",
+        lambda: pd.read_csv(GENE_EFFECT_PATH, index_col=0),
+    )
+    inputs = {
+        "All screens": {
+            "path": gene_effect,
+            "sort": "high",
+            "color": "#000000",
+        },
+    }
+    data, _ = timed_call(
+        timings,
+        n_jobs,
+        "load_datasets",
+        lambda: flex.load_datasets(inputs),
+    )
+    timed_call(timings, n_jobs, "load_gold_standard", flex.load_gold_standard)
+
+    name, dataset = next(iter(data.items()))
+    corr = timed_call(
+        timings,
+        n_jobs,
+        "perform_corr",
+        lambda: flex.perform_corr(dataset, CORR_FUNCTION),
+    )
+    timed_call(
+        timings,
+        n_jobs,
+        "pra_is_corr_true",
+        lambda: flex.pra(name, corr, is_corr=True),
+        is_corr=True,
+    )
+    timed_call(
+        timings,
+        n_jobs,
+        "pra_percomplex_is_corr_true",
+        lambda: flex.pra_percomplex(
+            name,
+            corr,
+            is_corr=True,
+            chunk_size=CHUNK_SIZE,
+            n_jobs=n_jobs,
+        ),
+        is_corr=True,
+    )
+    timed_call(
+        timings,
+        n_jobs,
+        "complex_contributions",
+        lambda: flex.complex_contributions(name),
+    )
+
+    timed_call(
+        timings,
+        n_jobs,
+        "plot_precision_recall_curve",
+        flex.plot_precision_recall_curve,
+    )
+    timed_call(timings, n_jobs, "plot_auc_scores", flex.plot_auc_scores)
+    timed_call(
+        timings,
+        n_jobs,
+        "plot_significant_complexes",
+        flex.plot_significant_complexes,
+    )
+    timed_call(
+        timings,
+        n_jobs,
+        "plot_percomplex_scatter",
+        lambda: flex.plot_percomplex_scatter(n_top=20),
+    )
+    timed_call(
+        timings,
+        n_jobs,
+        "plot_percomplex_scatter_bysize",
+        flex.plot_percomplex_scatter_bysize,
+    )
+    timed_call(
+        timings,
+        n_jobs,
+        "plot_complex_contributions",
+        flex.plot_complex_contributions,
+    )
+
+    timings.append(
+        {
+            "n_jobs": n_jobs,
+            "step": "total_runtime",
+            "seconds": perf_counter() - workflow_start,
+            "chunk_size": CHUNK_SIZE,
+            "corr_function": CORR_FUNCTION,
+            "is_corr": None,
+        }
+    )
+    output_folder.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame(timings).to_csv(output_folder / "benchmark_results.csv", index=False)
+    return timings
+
+
+def write_reports(timings: list[dict[str, Any]]) -> None:
+    raw = pd.DataFrame(timings)
+    raw.to_csv(BENCHMARK_ROOT / "benchmark_corum_njobs_comparison.csv", index=False)
+    summary = raw.pivot_table(
+        index=["n_jobs", "chunk_size", "corr_function"],
+        columns="step",
+        values="seconds",
+        aggfunc="first",
+    ).reset_index()
+    summary.columns.name = None
+    summary.to_csv(BENCHMARK_ROOT / "benchmark_corum_njobs_summary.csv", index=False)
+
+
+def main() -> None:
+    if not GENE_EFFECT_PATH.exists():
+        raise FileNotFoundError(f"Input dataset was not found: {GENE_EFFECT_PATH}")
+
+    BENCHMARK_ROOT.mkdir(parents=True, exist_ok=False)
+    all_timings: list[dict[str, Any]] = []
+    print(f"Benchmark output folder: {BENCHMARK_ROOT}")
+    print("mPR preparation and plot_mpr_summary are excluded.")
+
+    for n_jobs in N_JOBS_VALUES:
+        print(f"Running CORUM corr-reuse benchmark with n_jobs={n_jobs}")
+        all_timings.extend(run_n_jobs(n_jobs))
+        write_reports(all_timings)
+        gc.collect()
+
+    print(
+        "Benchmark summary saved to: "
+        f"{BENCHMARK_ROOT / 'benchmark_corum_njobs_summary.csv'}"
+    )
+
+
+if __name__ == "__main__":
+    main()

pythonflex/examples/runtime/runtime_benchmark_gobp_njobs_chunks.py

@@ -0,0 +1,319 @@
+"""Compare GOBP per-complex runtime across n_jobs and chunk sizes.
+
+Run from any directory with:
+    python path/to/src/pythonflex/examples/runtime_benchmark_gobp_njobs_chunks.py
+"""
+
+from __future__ import annotations
+
+import gc
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from time import perf_counter
+from typing import Any, Callable
+
+import pandas as pd
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[3]
+SRC_ROOT = PROJECT_ROOT / "src"
+if str(SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(SRC_ROOT))
+
+os.environ.setdefault("MPLBACKEND", "Agg")
+
+import pythonflex as flex  # noqa: E402
+
+
+GENE_EFFECT_PATH = Path(
+    "C:/Users/yd/Desktop/projects/_datasets/depmap/25Q2/gene_effect.csv"
+)
+GOLD_STANDARD = "GOBP"
+CORR_FUNCTION = "numpy_without_mask"
+MAX_NBYTES = "100M"
+STAGE_1_N_JOBS = (2, 4, 8, 16)
+STAGE_1_CHUNK_SIZE = 200
+STAGE_2_CHUNK_SIZES = (100, 400)
+BENCHMARK_ROOT = (
+    PROJECT_ROOT
+    / "output"
+    / f"runtime_benchmark_gobp_corr_reuse_njobs_chunks_{datetime.now():%Y%m%d_%H%M%S}"
+)
+
+
+def build_config(output_folder: Path, n_jobs: int, chunk_size: int) -> dict[str, Any]:
+    return {
+        "min_genes_in_complex": 2,
+        "min_genes_per_complex_analysis": 3,
+        "output_folder": str(output_folder),
+        "gold_standard": GOLD_STANDARD,
+        "color_map": "RdYlBu",
+        "jaccard": True,
+        "analysis_genes": "common",
+        "plotting": {
+            "save_plot": True,
+            "show_plot": False,
+            "output_type": "png",
+        },
+        "preprocessing": {
+            "fill_na": True,
+            "normalize": False,
+        },
+        "corr_function": CORR_FUNCTION,
+        "per_complex": {
+            "n_jobs": n_jobs,
+            "chunk_size": chunk_size,
+            "max_nbytes": MAX_NBYTES,
+        },
+        "logging": {
+            "visible_levels": ["DONE", "INFO", "WARNING", "ERROR"],
+        },
+    }
+
+
+def timed_call(
+    timings: list[dict[str, Any]],
+    stage: str,
+    n_jobs: int,
+    chunk_size: int,
+    step: str,
+    operation: Callable[[], Any],
+    *,
+    is_corr: bool | None = None,
+) -> Any:
+    start = perf_counter()
+    result = operation()
+    timings.append(
+        {
+            "gold_standard": GOLD_STANDARD,
+            "stage": stage,
+            "n_jobs": n_jobs,
+            "chunk_size": chunk_size,
+            "step": step,
+            "seconds": perf_counter() - start,
+            "corr_function": CORR_FUNCTION,
+            "is_corr": is_corr,
+            "status": "ok",
+            "error": "",
+        }
+    )
+    return result
+
+
+def run_combination(stage: str, n_jobs: int, chunk_size: int) -> list[dict[str, Any]]:
+    output_folder = BENCHMARK_ROOT / f"n_jobs_{n_jobs:02d}_chunk_{chunk_size}"
+    timings: list[dict[str, Any]] = []
+    workflow_start = perf_counter()
+
+    try:
+        timed_call(
+            timings,
+            stage,
+            n_jobs,
+            chunk_size,
+            "initialize",
+            lambda: flex.initialize(build_config(output_folder, n_jobs, chunk_size)),
+        )
+        gene_effect = timed_call(
+            timings,
+            stage,
+            n_jobs,
+            chunk_size,
+            "read_gene_effect",
+            lambda: pd.read_csv(GENE_EFFECT_PATH, index_col=0),
+        )
+        inputs = {
+            "All screens": {
+                "path": gene_effect,
+                "sort": "high",
+                "color": "#000000",
+            },
+        }
+        data, _ = timed_call(
+            timings,
+            stage,
+            n_jobs,
+            chunk_size,
+            "load_datasets",
+            lambda: flex.load_datasets(inputs),
+        )
+        timed_call(
+            timings,
+            stage,
+            n_jobs,
+            chunk_size,
+            "load_gold_standard",
+            flex.load_gold_standard,
+        )
+
+        name, dataset = next(iter(data.items()))
+        corr = timed_call(
+            timings,
+            stage,
+            n_jobs,
+            chunk_size,
+            "perform_corr",
+            lambda: flex.perform_corr(dataset, CORR_FUNCTION),
+        )
+        timed_call(
+            timings,
+            stage,
+            n_jobs,
+            chunk_size,
+            "pra_is_corr_true",
+            lambda: flex.pra(name, corr, is_corr=True),
+            is_corr=True,
+        )
+        timed_call(
+            timings,
+            stage,
+            n_jobs,
+            chunk_size,
+            "pra_percomplex_is_corr_true",
+            lambda: flex.pra_percomplex(
+                name,
+                corr,
+                is_corr=True,
+                chunk_size=chunk_size,
+                n_jobs=n_jobs,
+            ),
+            is_corr=True,
+        )
+        timed_call(
+            timings,
+            stage,
+            n_jobs,
+            chunk_size,
+            "complex_contributions",
+            lambda: flex.complex_contributions(name),
+        )
+    except Exception as exc:
+        print(
+            f"Run failed for n_jobs={n_jobs}, chunk_size={chunk_size}: {exc!r}",
+            file=sys.stderr,
+        )
+        timings.append(
+            {
+                "gold_standard": GOLD_STANDARD,
+                "stage": stage,
+                "n_jobs": n_jobs,
+                "chunk_size": chunk_size,
+                "step": "failed",
+                "seconds": perf_counter() - workflow_start,
+                "corr_function": CORR_FUNCTION,
+                "is_corr": None,
+                "status": "failed",
+                "error": repr(exc),
+            }
+        )
+    finally:
+        timings.append(
+            {
+                "gold_standard": GOLD_STANDARD,
+                "stage": stage,
+                "n_jobs": n_jobs,
+                "chunk_size": chunk_size,
+                "step": "total_runtime",
+                "seconds": perf_counter() - workflow_start,
+                "corr_function": CORR_FUNCTION,
+                "is_corr": None,
+                "status": "ok" if not any(t["status"] == "failed" for t in timings) else "failed",
+                "error": "",
+            }
+        )
+        output_folder.mkdir(parents=True, exist_ok=True)
+        pd.DataFrame(timings).to_csv(output_folder / "benchmark_results.csv", index=False)
+        gc.collect()
+
+    return timings
+
+
+def write_reports(timings: list[dict[str, Any]]) -> None:
+    raw = pd.DataFrame(timings)
+    raw.to_csv(
+        BENCHMARK_ROOT / "benchmark_gobp_njobs_chunks_comparison.csv",
+        index=False,
+    )
+
+    ok = raw[raw["status"] == "ok"].copy()
+    if ok.empty:
+        return
+
+    summary = ok.pivot_table(
+        index=["gold_standard", "stage", "n_jobs", "chunk_size", "corr_function"],
+        columns="step",
+        values="seconds",
+        aggfunc="first",
+    ).reset_index()
+    summary.columns.name = None
+    summary.to_csv(
+        BENCHMARK_ROOT / "benchmark_gobp_njobs_chunks_summary.csv",
+        index=False,
+    )
+
+
+def select_stage_1_winner(timings: list[dict[str, Any]]) -> int:
+    raw = pd.DataFrame(timings)
+    stage_1 = raw[
+        (raw["stage"] == "stage_1")
+        & (raw["chunk_size"] == STAGE_1_CHUNK_SIZE)
+        & (raw["status"] == "ok")
+        & (raw["step"].isin(["pra_percomplex_is_corr_true", "total_runtime"]))
+    ]
+    if stage_1.empty:
+        raise RuntimeError("No successful Stage 1 timings were recorded.")
+
+    pivot = stage_1.pivot_table(
+        index=["n_jobs"],
+        columns="step",
+        values="seconds",
+        aggfunc="first",
+    ).reset_index()
+    if "pra_percomplex_is_corr_true" not in pivot:
+        raise RuntimeError("Stage 1 completed without per-complex timing rows.")
+
+    sort_columns = ["pra_percomplex_is_corr_true"]
+    if "total_runtime" in pivot:
+        sort_columns.append("total_runtime")
+    winner = pivot.sort_values(sort_columns, ascending=True).iloc[0]
+    return int(winner["n_jobs"])
+
+
+def main() -> None:
+    if not GENE_EFFECT_PATH.exists():
+        raise FileNotFoundError(f"Input dataset was not found: {GENE_EFFECT_PATH}")
+
+    BENCHMARK_ROOT.mkdir(parents=True, exist_ok=False)
+    all_timings: list[dict[str, Any]] = []
+    print(f"Benchmark output folder: {BENCHMARK_ROOT}")
+    print("Plot calls, mPR preparation, and plot_mpr_summary are excluded.")
+
+    for n_jobs in STAGE_1_N_JOBS:
+        print(
+            f"Running GOBP Stage 1 benchmark: n_jobs={n_jobs}, "
+            f"chunk_size={STAGE_1_CHUNK_SIZE}"
+        )
+        all_timings.extend(run_combination("stage_1", n_jobs, STAGE_1_CHUNK_SIZE))
+        write_reports(all_timings)
+
+    winner_n_jobs = select_stage_1_winner(all_timings)
+    print(f"Stage 1 winner by per-complex runtime: n_jobs={winner_n_jobs}")
+
+    for chunk_size in STAGE_2_CHUNK_SIZES:
+        print(
+            f"Running GOBP Stage 2 benchmark: n_jobs={winner_n_jobs}, "
+            f"chunk_size={chunk_size}"
+        )
+        all_timings.extend(run_combination("stage_2", winner_n_jobs, chunk_size))
+        write_reports(all_timings)
+
+    print(
+        "Benchmark summary saved to: "
+        f"{BENCHMARK_ROOT / 'benchmark_gobp_njobs_chunks_summary.csv'}"
+    )
+
+
+if __name__ == "__main__":
+    main()