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/common.py

@@ -0,0 +1,85 @@
+"""Paths and immutable receipts for the x1 completion evaluation (CPU only)."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+from datetime import datetime, timezone
+
+ROOT = Path(__file__).resolve().parent
+S = ROOT.parents[2]
+F = S.parent / "paired_finetune_intradataset_20260927"
+ARMS = ("lora", "scsemi", "pairedcal", "raw", "refcal")
+COHORTS = ("imperial_eskd", "giroux2022", "ji2025_chili", "immicro", "ye2026_sepsis")
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def read(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def sha(path: Path) -> str:
+    with path.open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def atomic(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_suffix(path.suffix + f".tmp-{os.getpid()}")
+    temp.write_text(json.dumps(data, indent=2, allow_nan=False) + "\n")
+    temp.replace(path)
+
+
+def bind(path: Path) -> dict:
+    return {"path": str(path), "sha256": sha(path), "bytes": path.stat().st_size}
+
+
+def verify_receipt(path: Path) -> dict:
+    rec = read(path)
+    if rec.get("state") != "completed":
+        raise ValueError(f"Incomplete receipt: {path}")
+    for entry in rec["outputs"]:
+        source = Path(entry["path"])
+        if not source.is_file() or source.stat().st_size != entry["bytes"] or sha(source) != entry["sha256"]:
+            raise ValueError(f"Changed receipt output: {source}")
+    return rec
+
+
+def supports() -> list[Path]:
+    return [p for c in COHORTS for p in sorted((S / "protocol/splits" / c).rglob("support.json"))]
+
+
+def relative(support: Path) -> Path:
+    return support.parent.relative_to(S / "protocol/splits")
+
+
+def generated(rel: Path, arm: str) -> Path:
+    return S / "generated" / (Path("global") / rel.parts[0] if arm in ("raw", "refcal") else rel) / f"{arm}.npz"
+
+
+def candidates(rel: Path) -> list[Path]:
+    cohort, _, unit = rel.parts[:3]
+    result = [S / "scores" / rel / "score"]
+    if cohort == "giroux2022":
+        result.append(S / "recoveries/giroux_width_comparison_20261015" / unit / "score")
+    if cohort in ("imperial_eskd", "ji2025_chili"):
+        result.append(S / "recoveries/disease_width_comparison_20261015" / cohort / unit / "score")
+    if cohort == "immicro":
+        result.append(S / "recoveries/all_width_results_20261015" / rel / "score")
+    return result
+
+
+def output_record(base: Path, receipt: Path, state: str) -> dict:
+    cohort = read(base / "score/summary.json")["dataset"]
+    return {"state": state, "score_summary": str(base / "score/summary.json"),
+            "extras_manifest": str(base / "extras" / cohort / "strict/manifest.json"),
+            "contrast_manifest": str(base / "contrast" / cohort / "strict/manifest.json"),
+            "statistics_status": str(base / "statistics/status.json"),
+            "bootstrap_csv": str(base / "statistics/donor_bootstrap_2000.csv"),
+            "donor_deg_summary": str(base / "statistics/donor_deg/donor_deg_summary.csv"),
+            "individual_bootstrap_csv": str(base / "statistics/individual_donor_bootstrap_2000.csv"),
+            "receipt": str(receipt)}

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/cpu_queue.py

@@ -0,0 +1,167 @@
+"""Independent, bounded CPU queue; all available x1 LoRA results before comparator arms."""
+from __future__ import annotations
+
+import argparse
+import fcntl
+from pathlib import Path
+import sys
+import time
+
+from common import ARMS, ROOT, S, atomic, bind, candidates, generated, now, output_record, read, relative, supports, verify_receipt
+from readiness import generation_readiness
+
+sys.path.insert(0, str(S / "tools"))
+from runtime import Runtime
+
+PYTHON = "/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python"
+
+
+def inspect_unit(support: Path, arms: list[str]) -> dict:
+    rel = relative(support)
+    name = "-".join(rel.parts)
+    sup = read(support)
+    result = {"unit": name, "cohort": sup["cohort"], "relative": str(rel), "support_sha256": sup["sha256"],
+              "n_pairs": sup["n_pairs"], "support_path": str(support), "arms": {},
+              "scsemi_available": generation_readiness(S, rel, "scsemi", ROOT / "remote_operation_receipts")["ready"]}
+    canonical = S / "receipts" / f"{name}-score.json"
+    if canonical.exists() and read(canonical).get("state") == "completed":
+        adoption = ROOT / "adopted" / f"{name}.json"
+        if not adoption.exists():
+            verify_receipt(canonical)
+            base = S / "scores" / rel
+            if read(base / "scoring_support.json")["support_sha256"] != sup["sha256"]:
+                raise ValueError("Canonical full score support mismatch")
+            tracked = sorted(p for p in base.rglob("*") if p.is_file() and p.suffix in (".json", ".csv", ".parquet")
+                             and "_fetch_tmp" not in p.parts)
+            atomic(adoption, {"state": "completed", "at": now(), "kind": "canonical_full_adoption",
+                             "canonical_receipt": bind(canonical), "support_sha256": sup["sha256"],
+                             "outputs": [bind(p) for p in tracked]})
+        summary = read(S / "scores" / rel / "score/summary.json")
+        result["scsemi_available"] = "scsemi" in summary["arms"]
+        for arm in arms:
+            if arm in summary["arms"]:
+                result["arms"][arm] = output_record(S / "scores" / rel, adoption, "canonical_full_reused")
+    for arm in arms:
+        if arm in result["arms"]:
+            continue
+        base = ROOT / "units" / rel / arm
+        receipt = base / "FULL_RECEIPT.json"
+        if receipt.exists():
+            result["arms"][arm] = output_record(base, receipt, "full_completed")
+        elif (base / "receipts/score.json").exists():
+            result["arms"][arm] = output_record(base, base / "receipts/score.json", "core_only")
+        else:
+            ready = generation_readiness(S, rel, arm, ROOT / "remote_operation_receipts")
+            if not ready["ready"]:
+                result["arms"][arm] = ready
+                continue
+            cache = next((p for p in candidates(rel) if (p / "summary.json").exists()
+                          and arm in read(p / "summary.json").get("arms", [])), None)
+            result["arms"][arm] = {"state": "pending", "core_cache_candidate": str(cache) if cache else None,
+                                   "generation_readiness": ready}
+    return result
+
+
+def snapshot(arms: list[str], phase: str = "ready", active: dict | None = None) -> dict:
+    units = [inspect_unit(p, arms) for p in supports()]
+    full = {"full_completed", "canonical_full_reused"}
+    out = {"schema": "pbisc.x1.priority-evaluation.v1", "phase": phase, "at": now(), "active": active,
+           "units": units, "n_units": len(units), "x1_full_units": sum(u["arms"]["lora"]["state"] in full for u in units),
+           "all_selected_arms_completed": all(a["state"] in full for u in units for a in u["arms"].values()),
+           "gpu_operations": 0, "missing_scsemi": [u["unit"] for u in units if not u["scsemi_available"]]}
+    out["workers"] = {p.stem: read(p) for p in sorted(ROOT.glob("WORKER_*.json"))}
+    atomic(ROOT / "STATUS.json", out)
+    return out
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run", action="store_true")
+    parser.add_argument("--once", action="store_true")
+    parser.add_argument("--arms", default=",".join(ARMS))
+    parser.add_argument("--prepare-caches", action="store_true", help="Validate and expose all saved cores before expensive missing metrics")
+    parser.add_argument("--worker-index", type=int, default=0)
+    parser.add_argument("--workers", type=int, default=1)
+    parser.add_argument("--memory-gib", type=int, default=28, help="Hard memory cap for one full evaluation, no automatic resize")
+    args = parser.parse_args()
+    arms = args.arms.split(",")
+    if len(set(arms)) != len(arms) or "lora" not in arms or not set(arms) <= set(ARMS):
+        raise ValueError("Unique known arms including lora required")
+    if args.workers not in (1, 2) or not 0 <= args.worker_index < args.workers:
+        raise ValueError("One or two disjoint CPU workers supported")
+    if not 8 <= args.memory_gib <= 28:
+        raise ValueError("Full evaluation memory cap must be 8..28 GiB")
+    arms = ["lora"] + [x for x in arms if x != "lora"]
+    config = ROOT / "WORKER_CONFIG.json"
+    if config.exists() and read(config)["workers"] != args.workers:
+        raise ValueError("Worker partition changed; preserve and explicitly reconcile before launching")
+    atomic(config, {"workers": args.workers, "ownership": "stable supports() index modulo workers", "arms": arms})
+    lock = (ROOT / f".queue-worker{args.worker_index}.lock").open("a")
+    fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    worker_status = ROOT / f"WORKER_{args.worker_index}.json"
+    def mark(phase: str, active: dict | None = None) -> None:
+        atomic(worker_status, {"phase": phase, "active": active, "at": now(), "pid": __import__("os").getpid(),
+                               "worker_index": args.worker_index, "workers": args.workers, "memory_gib": args.memory_gib})
+    def owned(units: list[dict]) -> list[dict]:
+        return [u for i, u in enumerate(units) if i % args.workers == args.worker_index]
+    mark("ready")
+    state = snapshot(arms)
+    if not args.run:
+        print({k: state[k] for k in ("phase", "n_units", "x1_full_units", "missing_scsemi")})
+        return
+    runtime = Runtime(ROOT)
+    if args.prepare_caches:
+        for unit in owned(state["units"]):
+            for arm in arms:
+                info = unit["arms"][arm]
+                if info["state"] != "pending" or not info.get("core_cache_candidate"):
+                    continue
+                support = Path(unit["support_path"])
+                rel = relative(support)
+                mark("adopting_core", {"unit": unit["unit"], "arm": arm})
+                snapshot(arms, "adopting_core", {"unit": unit["unit"], "arm": arm})
+                runtime.execute("adopt-" + unit["unit"] + "-" + arm,
+                                [PYTHON, "-u", str(ROOT / "evaluate_arm.py"), "--support", str(support), "--arm", arm, "--adopt-only"],
+                                resource="cpu", memory_gib=4, threads=2,
+                                inputs=[support, ROOT / "evaluate_arm.py", ROOT / "common.py", generated(rel, arm).with_suffix(".log")],
+                                # The core-readiness process may have completed this same core meanwhile.
+                                # Its authoritative receipt is verified inside evaluate_arm's per-arm lock.
+                                outputs=[])
+        state = snapshot(arms)
+    while True:
+        active_arms = arms if state["x1_full_units"] == state["n_units"] else ["lora"]
+        jobs = [(u, arm) for arm in active_arms for u in owned(state["units"])
+                if u["arms"][arm]["state"] in ("pending", "core_only")]
+        if jobs:
+            unit, arm = jobs[0]
+            support = Path(unit["support_path"])
+            rel = relative(support)
+            active = {"unit": unit["unit"], "arm": arm}
+            mark("running", active)
+            snapshot(arms, "running", active)
+            command = [PYTHON, "-u", str(ROOT / "evaluate_arm.py"), "--support", str(support), "--arm", arm, "--threads", "2"]
+            runtime.execute("full-" + unit["unit"] + "-" + arm, command, resource="cpu", memory_gib=args.memory_gib, threads=2,
+                            inputs=[support, ROOT / "evaluate_arm.py", ROOT / "common.py", generated(rel, arm).with_suffix(".log")],
+                            outputs=[ROOT / "units" / rel / arm / "FULL_RECEIPT.json"], wait_seconds=7 * 86400)
+            state = snapshot(arms)
+            continue
+        if state["x1_full_units"] == state["n_units"]:
+            mark("assigned_ready_arms_completed")
+            snapshot(arms, "x1_complete_with_explicit_comparator_gaps" if not state["all_selected_arms_completed"] else "completed")
+            return
+        if args.once:
+            mark("ready_outputs_done_waiting_generation")
+            snapshot(arms, "ready_outputs_done_waiting_generation")
+            return
+        mark("waiting_generation_or_other_worker")
+        state = snapshot(arms, "waiting_generation_or_other_worker")
+        time.sleep(60)
+        state = snapshot(arms)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except BaseException as error:
+        atomic(ROOT / "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/fetch_remote.py

@@ -0,0 +1,73 @@
+"""Fetch only completed generation payloads and metadata, never scSemi model/work trees."""
+from __future__ import annotations
+import argparse
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+from common import ROOT, S, atomic, bind, now, read, sha
+
+
+def requested_paths() -> list[str]:
+    paths = []
+    for cohort, draws in (("giroux2022", range(5)), ("ji2025_chili", range(2))):
+        for draw in draws:
+            rel = Path(cohort) / "disease" / f"draw{draw}"
+            for arm in ("pairedcal", "scsemi"):
+                for suffix in (".npz", ".log", ".validation.json") if arm == "scsemi" else (".npz", ".log"):
+                    paths.append(str(Path("generated") / rel / f"{arm}{suffix}"))
+            paths.append(str(Path("scsemi") / rel / "inputs/inputs_manifest.json"))
+            for name in ("CONDITIONS.json", "test_raw.npz", "test_cal.npz"):
+                paths.append(str(Path("data") / rel / name))
+    return paths
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--execute", action="store_true")
+    args = parser.parse_args()
+    script = """import pathlib,json,hashlib,sys
+root=pathlib.Path(sys.argv[1]); result=[]
+for name in json.loads(sys.argv[2]):
+ p=root/name
+ if p.is_file():
+  with p.open('rb') as f: digest=hashlib.file_digest(f,'sha256').hexdigest()
+  result.append({'relative':name,'bytes':p.stat().st_size,'sha256':digest})
+print(json.dumps(result))
+"""
+    command = ["python3", "-c", script, str(S), __import__("json").dumps(requested_paths())]
+    result = subprocess.run(["ssh", "-o", "BatchMode=yes", "spark-0110", shlex.join(command)], capture_output=True, text=True, check=True)
+    files = __import__("json").loads(result.stdout)
+    manifest = {"state": "planned", "at": now(), "host": "server_2", "files": files,
+                "missing_remote": sorted(set(requested_paths()) - {x["relative"] for x in files}),
+                "scope": "completed NPZ/log/export validation/condition metadata only; no model or training directories"}
+    atomic(ROOT / "REMOTE_FETCH_PLAN.json", manifest)
+    if not args.execute:
+        print("Planned", len(files), "files; missing", manifest["missing_remote"])
+        return
+    verified = []
+    for entry in files:
+        target = S / entry["relative"]
+        if target.exists():
+            if target.stat().st_size != entry["bytes"] or sha(target) != entry["sha256"]:
+                raise ValueError(f"Existing file differs; preserve and inspect: {target}")
+            disposition = "existing_identical_preserved"
+        else:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            temporary = target.with_name(target.name + ".x1-fetch-partial")
+            if temporary.exists():
+                raise ValueError(f"Partial transfer needs inspection: {temporary}")
+            subprocess.run(["rsync", "-a", "--protect-args", "spark-0110:" + str(target), str(temporary)], check=True)
+            if temporary.stat().st_size != entry["bytes"] or sha(temporary) != entry["sha256"]:
+                raise ValueError(f"Transfer mismatch: {temporary}")
+            if target.exists():
+                raise ValueError(f"Concurrent writer produced target: {target}")
+            temporary.rename(target)
+            disposition = "copied_missing_only"
+        verified.append({**bind(target), "disposition": disposition})
+    atomic(ROOT / "REMOTE_FETCH_VERIFIED.json", {"state": "completed", "at": now(), "source": bind(ROOT / "REMOTE_FETCH_PLAN.json"),
+                                               "outputs": verified, "no_training_or_inference": True})
+
+
+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/readiness.py

@@ -0,0 +1,52 @@
+"""Discovery-only generation completion gate; file presence never means completion."""
+from __future__ import annotations
+import hashlib
+import json
+from pathlib import Path
+
+
+def generation_readiness(plan: Path, rel: Path, arm: str, receipt_store: Path | None = None) -> dict:
+    cohort = rel.parts[0]
+    tag = f"global-{cohort}-{arm}" if arm in ("raw", "refcal") else "-".join(rel.parts) + "-" + ("scexport" if arm == "scsemi" else arm)
+    canonical = plan / "receipts" / f"{tag}.json"
+    receipt = canonical if canonical.exists() else (receipt_store / canonical.name if receipt_store else canonical)
+    def waiting(reason: str, state: str = "waiting_generation") -> dict:
+        return {"ready": False, "state": state, "reason": reason, "operation_receipt": str(receipt)}
+    if not receipt.is_file():
+        return waiting("Completed generation operation receipt not available")
+    try:
+        operation = json.loads(receipt.read_text())
+    except (ValueError, OSError):
+        return waiting("Generation operation receipt is not readable JSON")
+    if operation.get("state") != "completed":
+        return waiting("Generation operation state=" + str(operation.get("state")),
+                       "generation_failed_needs_inspection" if operation.get("state") == "failed" else "waiting_generation")
+    folder = plan / "generated" / (Path("global") / cohort if arm in ("raw", "refcal") else rel)
+    npz, log = folder / f"{arm}.npz", folder / f"{arm}.log"
+    bindings = {entry.get("path"): entry for entry in operation.get("outputs", [])}
+    for file in (npz, log):
+        record = bindings.get(str(file))
+        if not record or not file.is_file() or file.stat().st_size <= 0 or file.stat().st_size != record.get("bytes"):
+            return waiting("Completed operation output is absent, empty, or not size-bound: " + file.name)
+    try:
+        log_bytes = log.read_bytes()
+        sampler = json.loads(log_bytes)
+    except (ValueError, OSError):
+        return waiting("Sampler receipt still empty, incomplete, or unreadable")
+    if not isinstance(sampler, dict):
+        return waiting("Sampler receipt must be a JSON object")
+    if hashlib.sha256(log_bytes).hexdigest() != bindings[str(log)].get("sha256"):
+        return waiting("Sampler receipt does not match completed operation hash", "generation_failed_needs_inspection")
+    if sampler.get("output") != str(npz) or sampler.get("output_sha256") != bindings[str(npz)].get("sha256"):
+        return waiting("Sampler receipt does not bind the completed generated output", "generation_failed_needs_inspection")
+    if arm == "scsemi":
+        validation = npz.with_suffix(".validation.json")
+        try:
+            proof = json.loads(validation.read_text())
+        except (ValueError, OSError):
+            return waiting("scSemi export validation pending")
+        if proof.get("passed") is not True or proof.get("npz_sha256") != sampler["output_sha256"]:
+            return waiting("scSemi export validation mismatch", "generation_failed_needs_inspection")
+    return {"ready": True, "state": "generation_completed", "operation_receipt": str(receipt),
+            "sampler_receipt": str(log), "npz_sha256": sampler["output_sha256"],
+            "note": "Full NPZ/support/checkpoint validation remains mandatory in evaluate_arm before scoring"}