Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/evaluation/core_readiness.py

@@ -0,0 +1,72 @@
+"""Expose new x1 LoRA core results immediately while independent full metrics proceed."""
+from __future__ import annotations
+import fcntl
+import subprocess
+from pathlib import Path
+import sys
+import time
+from common import ROOT, S, atomic, generated, now, read, relative, supports, verify_receipt
+from cpu_queue import PYTHON, snapshot
+from readiness import generation_readiness
+sys.path.insert(0, str(S / "tools"))
+from runtime import Runtime
+
+
+def main() -> None:
+    lock = (ROOT / ".core-readiness.lock").open("a")
+    fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    runtime = Runtime(ROOT)
+    arms = read(ROOT / "WORKER_CONFIG.json")["arms"]
+    while True:
+        done = 0
+        waiting = []
+        for support in supports():
+            rel = relative(support)
+            unit = "-".join(rel.parts)
+            canonical = S / "receipts" / f"{unit}-score.json"
+            core = ROOT / "units" / rel / "lora/receipts/score.json"
+            if canonical.exists() and read(canonical).get("state") == "completed":
+                done += 1
+                continue
+            if core.exists():
+                verify_receipt(core)
+                done += 1
+                continue
+            ready = generation_readiness(S, rel, "lora", ROOT / "remote_operation_receipts")
+            if not ready["ready"]:
+                waiting.append({"unit": unit, **ready})
+                continue
+            try:
+                runtime.preflight("cpu", 16)
+            except BlockingIOError as error:
+                waiting.append({"unit": unit, "state": "waiting_memory", "reason": str(error)})
+                continue
+            atomic(ROOT / "CORE_STATUS.json", {"phase": "running", "at": now(), "active": unit, "done": done})
+            command = [PYTHON, "-u", str(ROOT / "evaluate_arm.py"), "--support", str(support), "--arm", "lora",
+                       "--core-only", "--try-lock", "--threads", "2"]
+            wrapped = runtime.wrapped_command("core-" + unit, command, "cpu", 16, 2)
+            log = ROOT / "logs" / f"core-{unit}.log"
+            with log.open("a") as stream:
+                result = subprocess.run(wrapped, stdout=stream, stderr=subprocess.STDOUT)
+            if result.returncode == 75:
+                waiting.append({"unit": unit, "state": "owned_by_full_worker"})
+                continue
+            if result.returncode:
+                raise RuntimeError(f"Core evaluation failed for {unit}: exit {result.returncode}; inspect {log}")
+            verify_receipt(core)
+            done += 1
+            snapshot(arms, "core_results_updated")
+        atomic(ROOT / "CORE_STATUS.json", {"phase": "complete" if done == len(supports()) else "waiting",
+                                          "at": now(), "done": done, "total": len(supports()), "waiting": waiting})
+        snapshot(arms, "core_complete" if done == len(supports()) else "waiting_core_results")
+        if done == len(supports()):
+            return
+        time.sleep(30)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except BaseException as error:
+        atomic(ROOT / "CORE_ERROR.json", {"state": "stopped_needs_inspection", "at": now(), "error": str(error)})
+        raise

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/evaluation/evaluate_arm.py

@@ -0,0 +1,219 @@
+"""Complete missing CPU metrics for one arm; reuse validated core/annotation artifacts."""
+from __future__ import annotations
+
+import argparse
+import copy
+import fcntl
+import json
+import os
+from pathlib import Path
+import shutil
+import sys
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+for key in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMBA_NUM_THREADS"):
+    os.environ.setdefault(key, "2")
+from common import ROOT, S, F, atomic, bind, candidates, generated, now, read, relative, sha, verify_receipt
+
+sys.path[:0] = [str(S / "tools"), str(S / "recoveries/giroux_width_comparison_20261015")]
+import score_strict as ST
+from validator_fix import install
+import numpy as np
+import pandas as pd
+
+
+def validate_core(source: Path, arm: str, support: dict, binding: dict) -> dict:
+    """A saved score is reusable only for the identical source and evaluator contract."""
+    summary = read(source / "summary.json")
+    if summary["dataset"] != support["cohort"] or set(summary["donors"]) != set(support["test_sample_ids"]):
+        raise ValueError("Core score support mismatch")
+    record = summary.get("per_arm", {}).get(arm)
+    if not record or record["npz_sha256"] != binding["npz_sha256"] or Path(record["npz"]).resolve() != Path(binding["npz"]).resolve():
+        raise ValueError("Core score generated source mismatch")
+    reference_manifest = read(Path(summary["reference"]["cache"]) / "reference_manifest.json")
+    if reference_manifest["reference_sha256"] != summary["reference"]["reference_sha256"]:
+        raise ValueError("Core reference cache mismatch")
+    groups = {"giroux2022": (["severe"], ["mild"]),
+              "imperial_eskd": (["covid_positive"], ["covid_negative"]),
+              "ji2025_chili": (["TOL", "FU1"], ["BC", "AC"]),
+              "ye2026_sepsis": (["adult_sepsis", "ped_sepsis"], ["adult_HC", "adult_ICU_ctrl", "ped_HC", "ped_ICU_ctrl"])}
+    contrast = summary["contrast_definition"]
+    if support["cohort"] in groups:
+        case, control = groups[support["cohort"]]
+        if contrast.get("case_groups") != case or contrast.get("control_groups") != control:
+            raise ValueError("Core contrast definition mismatch")
+        condition = record.get("condition_for_broadcast") or {}
+        if condition.get("sha256") != binding.get("condition_sha256"):
+            raise ValueError("Core broadcast condition differs from strict generation")
+    elif support["cohort"] == "immicro" and contrast.get("enabled"):
+        raise ValueError("Healthy core unexpectedly has disease contrast")
+    for raw, expected in summary["code_sha256"].items():
+        if sha(Path(raw)) != expected:
+            raise ValueError(f"Core evaluator source changed: {raw}")
+    if support["cohort"] == "giroux2022":
+        exclusion = summary.get("gene_exclusion", {})
+        if not exclusion or sha(Path(exclusion["file"])) != exclusion["sha256"]:
+            raise ValueError("Giroux sex-gene exclusion missing or changed")
+    if not summary["contrast_definition"].get("enabled") and support["cohort"] != "immicro":
+        raise ValueError("Disease core lacks its contrast")
+    model_sha = ST._legacy_module("ft_common").ANNOT_MODEL_SHA
+    if record["annotation"]["model_pt_sha256"] != model_sha:
+        raise ValueError("Core annotator mismatch")
+    label_manifest = read(source / "arms" / arm / "labels/labels.manifest.json")
+    if label_manifest["model"]["model_pt_sha256"] != model_sha:
+        raise ValueError("Core label annotator mismatch")
+    # Row-alignment and gene-source binding are checked without reannotating cells.
+    cells = pd.read_parquet(source / "arms" / arm / "generated_cells.parquet", columns=["npz_row", "donor", "label"])
+    labels = pd.read_parquet(source / "arms" / arm / "labels/labels.parquet")
+    if not np.array_equal(labels.cell_index, np.arange(len(cells))) or not np.array_equal(labels.celltype_l1_pred.astype(str), cells.label.astype(str)):
+        raise ValueError("Core cell-label rows differ")
+    with np.load(binding["npz"], allow_pickle=False) as z:
+        sample_ids = z["sample_ids"].astype(str)
+        bulk_index = z["bulk_index"]
+        positions = {sample: i for i, sample in enumerate(sample_ids)}
+        selections = [np.flatnonzero(bulk_index == positions[x]) for x in summary["donors"]]
+        expected_rows = np.concatenate(selections)
+        expected_donors = np.repeat(summary["donors"], [len(x) for x in selections])
+    if not np.array_equal(cells.npz_row, expected_rows) or not np.array_equal(cells.donor.astype(str), expected_donors):
+        raise ValueError("Core rows do not match generated source")
+    return summary
+
+
+def adopt_core(source: Path, dest: Path, arm: str, support: dict, binding: dict) -> dict:
+    summary = validate_core(source, arm, support, binding)
+    if dest.exists():
+        raise ValueError(f"Unreceipted core destination exists: {dest}")
+    dest.mkdir(parents=True)
+    result = copy.deepcopy(summary)
+    result["arms"] = [arm]
+    result["per_arm"] = {arm: summary["per_arm"][arm]}
+    result["headline"] = {arm: summary["headline"][arm]}
+    result["core_reused_from"] = str(source)
+    atomic(dest / "summary.json", result)
+    for name in ("per_donor.csv", "contrast.csv"):
+        if (source / name).exists():
+            table = pd.read_csv(source / name)
+            table[table.arm == arm].to_csv(dest / name, index=False)
+    shutil.copytree(source / "arms" / arm, dest / "arms" / arm)
+    return {"source_summary": bind(source / "summary.json"), "source_arm": arm,
+            "validated_support_sha256": support["sha256"], "annotation_reexecuted": False}
+
+
+def scientific_files(folder: Path) -> list[Path]:
+    return sorted(p for p in folder.rglob("*") if p.is_file() and p.suffix in (".json", ".csv", ".parquet", ".txt")
+                  and not any(x in p.parts for x in ("_fetch_tmp", "receipts")))
+
+
+def complete_stage(folder: Path, name: str, files: list[Path], **extra: object) -> None:
+    atomic(folder / "receipts" / f"{name}.json", {"state": "completed", "stage": name, "at": now(),
+             "outputs": [bind(x) for x in files], **extra})
+
+
+def stage_done(folder: Path, name: str) -> bool:
+    receipt = folder / "receipts" / f"{name}.json"
+    if not receipt.exists():
+        if (folder / "receipts" / f"{name}.running.json").exists():
+            raise ValueError(f"Previous {name} did not complete; inspect before restart")
+        return False
+    verify_receipt(receipt)
+    return True
+
+
+def individual_bootstrap(folder: Path, arm: str) -> None:
+    long = pd.read_csv(folder / "statistics/per_donor_long.csv")
+    results = []
+    for metric, rows in long.groupby("metric", sort=True):
+        donor_values = rows.groupby("donor_id").value.mean().dropna().sort_index().to_numpy()
+        donor_values = donor_values[np.isfinite(donor_values)]
+        if len(donor_values) < 2:
+            results.append({"arm": arm, "metric": metric, "status": "not_estimable", "n_donors": len(donor_values)})
+            continue
+        rng = np.random.default_rng(20261012)
+        draws = donor_values[rng.integers(len(donor_values), size=(2000, len(donor_values)))].mean(1)
+        lo, hi = np.quantile(draws, [.025, .975])
+        results.append({"arm": arm, "metric": metric, "status": "ok", "estimate": float(donor_values.mean()),
+                        "ci_low": float(lo), "ci_high": float(hi), "n_donors": len(donor_values), "n_boot": 2000,
+                        "bootstrap_unit": "unique_donor_all_visits"})
+    pd.DataFrame(results).to_csv(folder / "statistics/individual_donor_bootstrap_2000.csv", index=False)
+    # One arm cannot define an inter-method difference. Keep a parseable empty
+    # table and explicit status, separately from the valid individual-arm CIs.
+    paired = folder / "statistics/donor_bootstrap_2000.csv"
+    if paired.read_text().strip() == "":
+        pd.DataFrame(columns=["metric", "arm", "baseline", "status", "reason", "estimate", "ci_low", "ci_high",
+                              "n_donors", "n_paired_samples", "n_excluded_nonfinite_pairs", "n_boot", "seed",
+                              "bootstrap_unit"]).to_csv(paired, index=False)
+    status_path = folder / "statistics/status.json"
+    status = read(status_path)
+    status["inter_method_bootstrap"] = {"status": "not_applicable", "reason": "Only one arm in this isolated evaluation",
+                                        "combined_comparisons": str(ROOT / "AGGREGATES.json")}
+    atomic(status_path, status)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--support", type=Path, required=True)
+    parser.add_argument("--arm", choices=("lora", "scsemi", "pairedcal", "raw", "refcal"), required=True)
+    parser.add_argument("--threads", type=int, default=2)
+    parser.add_argument("--adopt-only", action="store_true", help="Validate and adopt an existing core, without any new metrics")
+    parser.add_argument("--core-only", action="store_true", help="Compute or adopt core; leave extras and statistics to full queue")
+    parser.add_argument("--try-lock", action="store_true", help="Exit 75 when this arm is owned by another evaluation")
+    args = parser.parse_args()
+    if args.threads not in range(1, 5):
+        raise ValueError("threads must be 1..4")
+    install(ST)
+    support = ST.read_support(args.support)
+    rel = relative(args.support)
+    folder = ROOT / "units" / rel / args.arm
+    folder.mkdir(parents=True, exist_ok=True)
+    lock = (folder / ".arm.lock").open("a")
+    try:
+        fcntl.flock(lock, fcntl.LOCK_EX | (fcntl.LOCK_NB if args.try_lock else 0))
+    except BlockingIOError:
+        raise SystemExit(75)
+    final = folder / "FULL_RECEIPT.json"
+    if final.exists():
+        verify_receipt(final)
+        return
+    binding = ST.validate_generation_arm(args.arm, generated(rel, args.arm), support)
+    arms = [f"{args.arm}={generated(rel, args.arm)}"]
+    if not stage_done(folder, "score"):
+        atomic(folder / "receipts/score.running.json", {"at": now(), "support_sha256": support["sha256"]})
+        source = next((p for p in candidates(rel) if (p / "summary.json").exists() and args.arm in read(p / "summary.json").get("arms", [])), None)
+        provenance = {}
+        if args.adopt_only and source is None:
+            raise ValueError("No reusable core for --adopt-only")
+        if source:
+            provenance = adopt_core(source, folder / "score", args.arm, support, binding)
+            atomic(folder / "scoring_support.json", {"schema": "pbisc.paper.strict-score-binding.v1",
+                   "support_sha256": support["sha256"], "cohort": support["cohort"], "unit": support["unit"],
+                   "test_sample_ids": support["test_sample_ids"], "test_donor_ids": support["test_donor_ids"],
+                   "arm_bindings": {args.arm: binding}})
+            ST._existing_score(folder / "score", support, [args.arm])
+        else:
+            ST.main(["--support-manifest", str(args.support), "--out", str(folder), "--action", "score",
+                     "--arm", arms[0], "--threads", str(args.threads)])
+        complete_stage(folder, "score", scientific_files(folder / "score") + [folder / "scoring_support.json"],
+                       support_sha256=support["sha256"], binding=binding, reuse=provenance)
+    if args.adopt_only or args.core_only:
+        return
+    for action in ("extras", "contrast", "stats"):
+        if stage_done(folder, action):
+            continue
+        atomic(folder / "receipts" / f"{action}.running.json", {"at": now(), "support_sha256": support["sha256"]})
+        ST.main(["--support-manifest", str(args.support), "--out", str(folder), "--action", action,
+                 "--arm", arms[0], "--threads", str(args.threads)])
+        if action == "stats":
+            individual_bootstrap(folder, args.arm)
+        complete_stage(folder, action, scientific_files(folder / ("statistics" if action == "stats" else action)))
+    atomic(final, {"schema": "pbisc.x1.full-evaluation.v1", "state": "completed", "at": now(),
+           "support_sha256": support["sha256"], "arm": args.arm, "generation_binding": binding,
+           "source_files": [bind(p) for p in [Path(__file__), ROOT / "common.py", S / "tools/score_strict.py",
+                                             S / "tools/donor_statistics.py", S / "tools/donor_limma.R",
+                                             F / "tools/score_ft.py", F / "tools/extra_metrics.py", F / "tools/contrast_extra.py"]],
+           "outputs": [bind(p) for p in scientific_files(folder)],
+           "note": "Per-arm complete metrics; paired inter-method bootstrap is in aggregate output, when both arms are ready.",
+           "gpu_operations": 0})
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/evaluation/finish_chili1_export.py

@@ -0,0 +1,22 @@
+"""Remote CPU-only export of already completed CHILI draw1 scSemi inference."""
+from pathlib import Path
+import json
+import sys
+S = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(S / "tools"))
+import campaign
+from runtime import Runtime
+
+
+class CpuOnly(Runtime):
+    def execute(self, *args, **kwargs):
+        if kwargs.get("resource", "cpu") != "cpu":
+            raise RuntimeError("No new GPU operation is authorized for this export")
+        return super().execute(*args, **kwargs)
+
+
+if __name__ == "__main__":
+    support = S / "protocol/splits/ji2025_chili/disease/draw1/support.json"
+    status = json.loads((S / "scsemi/ji2025_chili/disease/draw1/status.json").read_text())
+    assert status["pretrain_complete"] and status["infer_complete"], "Inference is not complete; no GPU fallback"
+    campaign.run_scsemi(CpuOnly(S), support)

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/evaluation/test_evaluation.py

@@ -0,0 +1,84 @@
+"""Metadata and reuse regression checks: no GPU, new scoring, or generated expression reads."""
+import copy
+import tempfile
+import unittest
+from pathlib import Path
+from common import ROOT, S, atomic, bind, read, relative, supports, verify_receipt
+from evaluate_arm import validate_core, individual_bootstrap
+import importlib.util
+_spec = importlib.util.spec_from_file_location("priority_evaluation_aggregate", ROOT / "aggregate.py")
+_aggregate = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_aggregate)
+matched_draw_metadata = _aggregate.matched_draw_metadata
+import pandas as pd
+
+
+class ReuseTests(unittest.TestCase):
+    def test_single_arm_bootstrap_parseable_and_not_applicable(self):
+        with tempfile.TemporaryDirectory() as directory:
+            folder = Path(directory)
+            stats = folder / "statistics"
+            stats.mkdir()
+            pd.DataFrame({"donor_id": ["a", "b"], "metric": ["error", "error"], "value": [0.1, 0.2]}).to_csv(stats / "per_donor_long.csv", index=False)
+            (stats / "donor_bootstrap_2000.csv").write_text("\n")
+            atomic(stats / "status.json", {"disease_deg": {"status": "not_applicable"}})
+            individual_bootstrap(folder, "lora")
+            paired = pd.read_csv(stats / "donor_bootstrap_2000.csv")
+            self.assertTrue(paired.empty)
+            self.assertIn("ci_low", paired.columns)
+            self.assertEqual(read(stats / "status.json")["inter_method_bootstrap"]["status"], "not_applicable")
+            self.assertEqual(len(pd.read_csv(stats / "individual_donor_bootstrap_2000.csv")), 1)
+
+    def test_matched_draws_exclude_unmatched_and_nonfinite(self):
+        rows = pd.DataFrame([
+            {"draw": draw, "donor_id": "d", "sample_id": "s", "arm": arm, "metric": "m", "value": value}
+            for draw, arm, value in [("draw0", "lora", 0.1), ("draw0", "scsemi", 0.2),
+                                     ("draw1", "lora", 0.3), ("draw2", "scsemi", 0.4),
+                                     ("draw3", "lora", float("nan")), ("draw3", "scsemi", 0.5)]])
+        result = matched_draw_metadata(rows, "scsemi", "m")
+        self.assertEqual(result["n_draws_matched"], 1)
+        self.assertEqual(result["matched_draw_ids"], '["draw0"]')
+        self.assertEqual(result["n_draws_union_available"], 4)
+
+    def test_exact_requested_supports(self):
+        paths = supports()
+        self.assertEqual(len(paths), 40)
+        self.assertEqual(len({str(relative(p)) for p in paths}), 40)
+        first, second = paths[0::2], paths[1::2]
+        self.assertEqual(len(first), 20)
+        self.assertEqual(len(second), 20)
+        self.assertFalse(set(first) & set(second))
+        self.assertEqual(set(first) | set(second), set(paths))
+
+    def test_receipt_changes_rejected(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            file = root / "table.csv"
+            file.write_text("a,b\n1,2\n")
+            rec = root / "receipt.json"
+            atomic(rec, {"state": "completed", "outputs": [bind(file)]})
+            verify_receipt(rec)
+            file.write_text("a,b\n2,2\n")
+            with self.assertRaises(ValueError):
+                verify_receipt(rec)
+
+    def test_real_core_contract_and_negatives(self):
+        source = S / "recoveries/giroux_width_comparison_20261015/draw0/score"
+        summary = read(source / "summary.json")
+        support = read(S / "protocol/splits/giroux2022/disease/draw0/support.json")
+        record = summary["per_arm"]["lora"]
+        binding = {"npz": record["npz"], "npz_sha256": record["npz_sha256"],
+                   "condition_sha256": record["condition_for_broadcast"]["sha256"]}
+        self.assertEqual(validate_core(source, "lora", support, binding)["dataset"], "giroux2022")
+        bad = copy.deepcopy(support)
+        bad["test_sample_ids"] = bad["test_sample_ids"][:-1]
+        with self.assertRaises(ValueError):
+            validate_core(source, "lora", bad, binding)
+        with self.assertRaises(ValueError):
+            validate_core(source, "lora", support, {**binding, "npz_sha256": "0" * 64})
+        with self.assertRaises(ValueError):
+            validate_core(source, "lora", support, {**binding, "condition_sha256": "0" * 64})
+
+
+if __name__ == "__main__":
+    unittest.main()