Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/rare_metrics.py

@@ -0,0 +1,121 @@
+"""Zero-aware rare-state statistics; sample is the matching unit and donor is the bootstrap unit."""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy.stats import mannwhitneyu, spearmanr
+
+
+def validate_marker_coverage(state: dict, symbols: list[str]) -> None:
+    if state["kind"] != "markers":
+        return
+    needed = set(state["genes"])
+    needed.update(g for group in state.get("require_any", []) for g in group)
+    needed.update(state.get("exclude", []))
+    missing = sorted(needed.difference(symbols))
+    if missing:
+        raise ValueError(f'{state["name"]}: missing mandatory marker(s): {", ".join(missing)}')
+
+
+def call_marker_state(counts: np.ndarray, symbols: list[str], state: dict) -> np.ndarray:
+    validate_marker_coverage(state, symbols)
+    if counts.ndim != 2 or counts.shape[1] != len(symbols):
+        raise ValueError("marker counts and symbols are not aligned")
+    pos = {g: i for i, g in enumerate(symbols)}
+    detected = counts > 0
+    hit = detected[:, [pos[g] for g in state["genes"]]].sum(axis=1) >= state["k"]
+    for group in state.get("require_any", []):
+        hit &= detected[:, [pos[g] for g in group]].any(axis=1)
+    for gene in state.get("exclude", []):
+        hit &= ~detected[:, pos[gene]]
+    return hit
+
+
+def validate_design(manifest: dict) -> str:
+    design = manifest["design"]
+    if design not in {"strict5pair", "legacy_5donor", "fivefold"}:
+        raise ValueError(f"unknown design {design}")
+    if design != "strict5pair":
+        return "diagnostic"
+    samples = manifest["train_sample_ids"]
+    donors = manifest["train_donor_ids"]
+    if len(samples) != 5 or len(donors) != 5 or len(set(samples)) != 5 or len(set(donors)) != 5:
+        raise ValueError("strict5pair needs exactly five samples from five unique donor IDs")
+    return "strict"
+
+
+def _with_rates(rows: pd.DataFrame) -> pd.DataFrame:
+    x = rows.copy()
+    for side in ("obs", "gen"):
+        p, s = x[f"{side}_parent"], x[f"{side}_state"]
+        if (p < 0).any() or (s < 0).any() or (s > p).any():
+            raise ValueError(f"{side} state counts must be between 0 and parent counts")
+        x[f"{side}_pct"] = 100 * s / p.where(p > 0)
+        if f"{side}_total" in x:
+            if (x[f"{side}_total"] < p).any():
+                raise ValueError(f"{side} total below parent")
+            x[f"{side}_overall_pct"] = 100 * s / x[f"{side}_total"].where(x[f"{side}_total"] > 0)
+    return x
+
+
+def aggregate_donors(rows: pd.DataFrame) -> pd.DataFrame:
+    """Sum counts across all visits from a donor; never treat visit IDs as independent donors."""
+    cols = ["obs_parent", "obs_state", "gen_parent", "gen_state"]
+    cols += [c for c in ("obs_total", "gen_total") if c in rows]
+    if rows.groupby("sample_id").donor_id.nunique().gt(1).any():
+        raise ValueError("sample maps to multiple donors")
+    summed = rows.groupby("donor_id", dropna=False, as_index=False)[cols].sum()
+    if "group" in rows:
+        group = rows.groupby("donor_id").group.agg(
+            lambda v: v.iloc[0] if v.nunique() == 1 else "mixed")
+        summed["group"] = summed.donor_id.map(group)
+    return _with_rates(summed)
+
+
+def high_low_abundance_auroc(donors: pd.DataFrame) -> float:
+    """Rank generated abundance for donors above/below median observed abundance."""
+    x = donors[["gen_pct", "obs_pct"]].dropna()
+    if x.obs_pct.nunique() < 2:
+        return float("nan")
+    med = x.obs_pct.median()
+    hi = x.loc[x.obs_pct > med, "gen_pct"]
+    lo = x.loc[x.obs_pct < med, "gen_pct"]
+    if len(hi) < 2 or len(lo) < 2:
+        return float("nan")
+    return float(mannwhitneyu(hi, lo).statistic / (len(hi) * len(lo)))
+
+
+def abundance_summary(rows: pd.DataFrame) -> dict:
+    x = _with_rates(rows)
+    d = aggregate_donors(rows)
+    valid_sample = x[["obs_pct", "gen_pct"]].dropna()
+    valid_donor = d[["obs_pct", "gen_pct"]].dropna()
+    op, gp = x.obs_parent.sum(), x.gen_parent.sum()
+    obs_pct = 100 * x.obs_state.sum() / op if op else float("nan")
+    gen_pct = 100 * x.gen_state.sum() / gp if gp else float("nan")
+    rho = (float(spearmanr(valid_donor.obs_pct, valid_donor.gen_pct).statistic)
+           if len(valid_donor) >= 3 and valid_donor.obs_pct.nunique() > 1
+           and valid_donor.gen_pct.nunique() > 1 else float("nan"))
+    return dict(n_samples=int(len(x)), n_donors=int(len(d)), obs_state=int(x.obs_state.sum()),
+                obs_parent=int(op), gen_state=int(x.gen_state.sum()), gen_parent=int(gp),
+                obs_pct=obs_pct, gen_pct=gen_pct,
+                generated_zero_samples=int((x.gen_state == 0).sum()),
+                generated_zero_donors=int((d.gen_state == 0).sum()),
+                parent_zero_samples=int((x.gen_parent == 0).sum()),
+                mae_sample_pp=float((valid_sample.obs_pct - valid_sample.gen_pct).abs().mean())
+                if len(valid_sample) else float("nan"),
+                mae_donor_pp=float((valid_donor.obs_pct - valid_donor.gen_pct).abs().mean())
+                if len(valid_donor) else float("nan"),
+                spearman_donor=rho,
+                high_low_abundance_auroc=high_low_abundance_auroc(d))
+
+
+def bootstrap_mae(rows: pd.DataFrame, *, seed: int = 20261012, n_boot: int = 2000) -> tuple[float, float]:
+    """Percentile interval for donor mean absolute percentage-point error."""
+    d = aggregate_donors(rows)[["obs_pct", "gen_pct"]].dropna()
+    err = (d.obs_pct - d.gen_pct).abs().to_numpy()
+    if not len(err):
+        return float("nan"), float("nan")
+    rng = np.random.default_rng(seed)
+    means = np.mean(err[rng.integers(len(err), size=(n_boot, len(err)))], axis=1)
+    return tuple(float(v) for v in np.quantile(means, [0.025, 0.975]))

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/rescore_pretrain_ablations.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""CPU-only, donor-balanced Figure 2 pretraining ablation P/C rescore.
+
+This deliberately creates a new k=10 recipe. The saved k=15 architecture
+scores are cited as historical evidence, never silently merged into this CSV.
+No model is loaded, and compressed NPZ expression members are read in chunks.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import hashlib
+import json
+import zipfile
+from pathlib import Path
+
+import h5py
+import numpy as np
+from scipy import sparse
+from sklearn.decomposition import PCA
+from sklearn.neighbors import NearestNeighbors
+
+MODEL = Path(__file__).resolve().parents[3]
+ROOT = Path(__file__).resolve().parents[1]
+ARCH = MODEL / "analysis/scsemi_benchmark_diffusion_20260913"
+PANEL = MODEL / "analysis/floor01_benchmark_20260923"
+BENCH = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/bulk2sc-paper/results/scsemiprofiler_vs_pbisc_heldout_20260629/inputs/004_A_GSE135779_SLE_PBMC/primary_kmeans")
+TRUTH = BENCH / "target_truth_sc.h5ad"
+GENES_TSV = Path("/home/sj_server_1/gblee/datalake/single-cell/GSE135779/GSE135779_genes.tsv.gz")
+ARCH_NAMES = ("bern6k", "bernctx2048", "bern4xctx512", "bern4x")
+PANEL_NAMES = ("f012k", "f013k", "f016k", "f01p15k")
+SEED = 20261012
+POISSON_SEED = 20260916
+
+
+def sha_array(a: np.ndarray) -> str:
+    return hashlib.sha256(np.ascontiguousarray(a).tobytes()).hexdigest()
+
+
+def gene_columns(have, want) -> np.ndarray:
+    if len(set(have)) != len(have) or len(set(want)) != len(want):
+        raise ValueError("duplicate gene identifiers")
+    positions = {g: i for i, g in enumerate(have)}
+    missing = [g for g in want if g not in positions]
+    if missing:
+        raise ValueError(f"{len(missing)} missing genes; first={missing[:3]}")
+    return np.asarray([positions[g] for g in want], dtype=np.int64)
+
+
+def balanced_real_split(labels, donors, per_donor: int, seed: int):
+    rng = np.random.default_rng(seed)
+    one, two = [], []
+    labels = np.asarray(labels)
+    for donor in donors:
+        rows = np.flatnonzero(labels == donor)
+        if rows.size < 2 * per_donor:
+            raise ValueError(f"{donor}: only {rows.size} real cells for two independent splits")
+        chosen = rng.choice(rows, size=2 * per_donor, replace=False)
+        one.extend(chosen[:per_donor]); two.extend(chosen[per_donor:])
+    return np.asarray(one, np.int64), np.asarray(two, np.int64)
+
+
+def score_pc(reference: np.ndarray, candidate: np.ndarray, k: int = 10) -> dict:
+    if len(reference) <= k or not len(candidate):
+        raise ValueError("too few cells for local radius")
+    nn_r = NearestNeighbors(n_neighbors=k + 1, algorithm="brute", n_jobs=1).fit(reference)
+    # Bound query working memory independently of the total cell count.
+    def batched_query(fitted, queries, neighbors):
+        distances, indices = [], []
+        for start in range(0, len(queries), 256):
+            d, i = fitted.kneighbors(queries[start:start + 256], n_neighbors=neighbors, return_distance=True)
+            distances.append(d); indices.append(i)
+        return np.concatenate(distances), np.concatenate(indices)
+
+    radius = batched_query(nn_r, reference, k + 1)[0][:, k]
+    nn_c = NearestNeighbors(n_neighbors=1, algorithm="brute", n_jobs=1).fit(candidate)
+    d_rg = batched_query(nn_c, reference, 1)[0][:, 0]
+    d_gr, i_gr = batched_query(nn_r, candidate, 1)
+    coverage = float(np.mean(d_rg <= radius))
+    precision = float(np.mean(d_gr[:, 0] <= radius[i_gr[:, 0]]))
+    return {"coverage": coverage, "precision": precision,
+            "f1": float(2 * coverage * precision / (coverage + precision)) if coverage + precision else 0.0,
+            "median_real_to_candidate_distance": float(np.median(d_rg)),
+            "median_candidate_to_real_distance": float(np.median(d_gr))}
+
+
+def cp10k_log1p(x: np.ndarray) -> np.ndarray:
+    x = np.asarray(x, np.float32)
+    if not np.isfinite(x).all() or (x < 0).any():
+        raise ValueError("negative or nonfinite count/rate")
+    totals = x.sum(axis=1, keepdims=True)
+    return np.log1p(np.divide(x * 10000, totals, out=np.zeros_like(x), where=totals > 0))
+
+
+def zip_npy_metadata(path: Path, key: str) -> tuple[tuple[int, ...], np.dtype, bool]:
+    with zipfile.ZipFile(path) as z, z.open(key + ".npy") as f:
+        version = np.lib.format.read_magic(f)
+        if version == (1, 0):
+            shape, fortran, dtype = np.lib.format.read_array_header_1_0(f)
+        elif version == (2, 0):
+            shape, fortran, dtype = np.lib.format.read_array_header_2_0(f)
+        else:
+            raise ValueError(f"unsupported NPY header version {version} in {path}:{key}")
+    return shape, dtype, fortran
+
+
+def stream_selected_npz(path: Path, rows: np.ndarray, cols: np.ndarray, batch: int = 128) -> np.ndarray:
+    shape, dtype, fortran = zip_npy_metadata(path, "generated_counts")
+    if len(shape) != 2 or fortran or dtype != np.dtype("<f4"):
+        raise ValueError(f"unsupported matrix layout in {path}: {shape} {dtype} {fortran}")
+    if np.any(rows < 0) or np.any(rows >= shape[0]):
+        raise ValueError("selected generated row outside matrix")
+    selected = np.zeros(shape[0], bool); selected[rows] = True
+    output = np.empty((len(rows), len(cols)), np.float32)
+    # The output follows the caller's row order. The ZIP member is read once.
+    dest = np.full(shape[0], -1, np.int64); dest[rows] = np.arange(len(rows))
+    with zipfile.ZipFile(path) as z, z.open("generated_counts.npy") as f:
+        version = np.lib.format.read_magic(f)
+        if version == (1, 0):
+            np.lib.format.read_array_header_1_0(f)
+        elif version == (2, 0):
+            np.lib.format.read_array_header_2_0(f)
+        else:
+            raise ValueError(f"unsupported NPY header version {version}")
+        row_bytes = shape[1] * dtype.itemsize
+        for start in range(0, shape[0], batch):
+            stop = min(shape[0], start + batch)
+            block = f.read((stop - start) * row_bytes)
+            if len(block) != (stop - start) * row_bytes:
+                raise IOError(f"truncated generated_counts member: {path}")
+            needed = np.flatnonzero(selected[start:stop])
+            if needed.size:
+                matrix = np.frombuffer(block, dtype=dtype).reshape(stop - start, shape[1])
+                output[dest[start + needed]] = matrix[needed][:, cols]
+    return output
+
+
+def npz_metadata(path: Path):
+    with np.load(path, allow_pickle=False) as z:
+        return {"gene_ids": z["gene_ids"].astype(str).tolist(),
+                "sample_ids": z["sample_ids"].astype(str).tolist(),
+                "bulk_index": z["bulk_index"].astype(np.int32),
+                "generation": json.loads(str(z["metadata_json"].item()))}
+
+
+def selected_generated_rows(bulk_index, n_donors: int, per_donor: int, seed: int):
+    rng = np.random.default_rng(seed)
+    rows = []
+    for donor in range(n_donors):
+        candidate = np.flatnonzero(bulk_index == donor)
+        if len(candidate) < per_donor:
+            raise ValueError(f"generated donor {donor} has {len(candidate)} cells")
+        rows.extend(rng.choice(candidate, per_donor, replace=False))
+    return np.asarray(rows, np.int64)
+
+
+def load_real(rows: np.ndarray, panel_cols: np.ndarray) -> np.ndarray:
+    with h5py.File(TRUTH) as f:
+        x = f["X"]
+        csr = sparse.csr_matrix((x["data"][:], x["indices"][:], x["indptr"][:]), shape=tuple(x.attrs["shape"]))
+    return csr[rows][:, panel_cols].toarray().astype(np.float32)
+
+
+def panel_gene_ids() -> list[str]:
+    # Reuse the measured 1006-gene axis from the existing floor-0.1% evaluation.
+    manifest = PANEL / "metrics/panel_2980_all_diffusion/pbmc5_other/evaluation_manifest.json"
+    ids = json.loads(manifest.read_text())["evaluation_gene_ids"]
+    if len(ids) != 1006:
+        raise ValueError(f"expected 1006 measured genes, got {len(ids)}")
+    return ids
+
+
+def benchmark_gene_ids():
+    with gzip.open(GENES_TSV, "rt") as f:
+        raw = [line.split("\t", 1)[0] for line in f]
+    with (BENCH / "gene_panel.csv").open(newline="") as f:
+        panel = list(csv.DictReader(f))
+    return [raw[int(x["raw_gene_index"])] for x in panel]
+
+
+def family_specs():
+    return {"architecture_floor1pct": [(n, ARCH / f"generated_{n}_e16.npz") for n in ARCH_NAMES],
+            "panel_floor0.1pct": [(n, PANEL / f"generated_{n}_e16.npz") for n in PANEL_NAMES]}
+
+
+def write_legacy_architecture_snapshot():
+    """Copy measured E16 rows into a separate, explicitly non-comparable table."""
+    legacy_rows = []
+    for name in ARCH_NAMES:
+        source = ARCH / f"metrics/real_manifold_with{name}_epochs/real_manifold_coverage_metrics.csv"
+        if not source.exists():
+            raise FileNotFoundError(source)
+        with source.open(newline="") as f:
+            matches = [r for r in csv.DictReader(f) if r["method"] == f"diffusion_{name}_e16"]
+        if len(matches) != 1:
+            raise ValueError(f"{source}: expected exactly one E16 row, got {len(matches)}")
+        r = matches[0]
+        legacy_rows.append({"method": name, "coverage_1x": r["real_to_generated_coverage_1x"],
+            "precision_1x": r["generated_to_real_precision_1x"], "f1_1x": r["bidirectional_f1_1x"],
+            "real_cells": r["real_cells_used"], "generated_cells": r["generated_cells_used"],
+            "local_k": r["local_k"], "genes": r["panel_genes"], "source_csv": str(source),
+            "comparability": "legacy k15 2980 genes; separate recipe"})
+    out = ROOT / "source_data/ablation_pretrain_legacy_architecture_k15.csv"
+    with out.open("w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=list(legacy_rows[0]))
+        writer.writeheader(); writer.writerows(legacy_rows)
+    return out
+
+
+def plan():
+    result = {}
+    for family, sources in family_specs().items():
+        details = {}
+        for name, path in sources:
+            if not path.exists():
+                details[name] = {"path": str(path), "status": "missing"}
+            else:
+                shape, dtype, _ = zip_npy_metadata(path, "generated_counts")
+                details[name] = {"path": str(path), "bytes": path.stat().st_size,
+                                 "matrix_shape": shape, "matrix_dtype": str(dtype), "status": "present"}
+        result[family] = details
+    return result
+
+
+def execute(per_donor: int, families: list[str]):
+    if per_donor < 11 or per_donor > 500:
+        raise ValueError("per-donor count must be 11..500")
+    import pandas as pd
+
+    output_csv = ROOT / "source_data/ablation_pretrain_pc.csv"
+    output_json = ROOT / "source_data/ablation_pretrain_pc_receipt.json"
+    ids = panel_gene_ids()
+    bench_ids = benchmark_gene_ids()
+    truth_cols = gene_columns(bench_ids, ids)
+    with h5py.File(TRUTH) as f:
+        obs = f["obs/donor_id"]
+        categories = [x.decode() if isinstance(x, bytes) else str(x) for x in obs["categories"][:]]
+        labels = np.asarray(categories)[obs["codes"][:]]
+    rows_out = []
+    receipt = {"schema": "pbisc.fig2.pretrain_pc.v1", "recipe": {
+        "n_pcs": 50, "pca_fit": "real R1 only; randomized SVD; all common measured genes",
+        "normalization": "panel CP10k and log1p, independent per cell",
+        "readout": "generated_counts as Poisson rate; one draw after common-gene subset; real counts untouched",
+        "poisson_seed": POISSON_SEED, "local_k": 10, "real_split_seed": SEED,
+        "generated_row_seed": SEED, "per_donor_per_set": per_donor,
+        "distance": "Euclidean in fixed real-R1 PCA50; exact brute kNN in bounded batches",
+        "cells_as_replicates": False},
+        "gene_axis": {"ids_sha256": sha_array(np.asarray(ids, dtype="S20")), "n": len(ids),
+                      "source": str(PANEL / "metrics/panel_2980_all_diffusion/pbmc5_other/evaluation_manifest.json")},
+        "truth_source": str(TRUTH), "families": {}, "limitations": [
+            "One generation seed and one Poisson readout seed; donor is the biological unit.",
+            "Architecture floor-1% and panel floor-0.1% families are distinct comparisons.",
+            "Legacy architecture manifold scores use k=15 and a different unbalanced, unpoissonized recipe; they are not mixed into this table."]}
+    for family in families:
+        specs = family_specs()[family]
+        present = [(n, p) for n, p in specs if p.exists()]
+        missing = [n for n, p in specs if not p.exists()]
+        if missing:
+            receipt["families"][family] = {"status": "incomplete", "missing": missing}
+            continue
+        metadata = {n: npz_metadata(p) for n, p in present}
+        sample_ids = metadata[present[0][0]]["sample_ids"]
+        if any(metadata[n]["sample_ids"] != sample_ids for n, _ in present):
+            raise ValueError(f"{family}: donor order differs")
+        if any(not np.array_equal(metadata[n]["bulk_index"], metadata[present[0][0]]["bulk_index"]) for n, _ in present):
+            raise ValueError(f"{family}: generated row donor map differs")
+        if not set(sample_ids).issubset(set(categories)):
+            raise ValueError(f"{family}: generated donors absent from truth")
+        r1, r2 = balanced_real_split(labels, sample_ids, per_donor, SEED)
+        g_rows = selected_generated_rows(metadata[present[0][0]]["bulk_index"], len(sample_ids), per_donor, SEED)
+        R1 = cp10k_log1p(load_real(r1, truth_cols)); R2 = cp10k_log1p(load_real(r2, truth_cols))
+        pca = PCA(n_components=50, svd_solver="randomized", random_state=SEED)
+        Rp = pca.fit_transform(R1).astype(np.float32)
+        R2p = pca.transform(R2).astype(np.float32)
+        base = score_pc(Rp, R2p)
+        rows_out.append({"family": family, "method": "real_R2_independent", "n_genes": len(ids),
+                         "n_donors": len(sample_ids), "real_cells": len(r1), "candidate_cells": len(r2),
+                         "local_k": 10, **base})
+        f_receipt = {"status": "complete", "donor_ids": sample_ids,
+                     "real_R1_rows_sha256": sha_array(r1), "real_R2_rows_sha256": sha_array(r2),
+                     "generated_rows_sha256": sha_array(g_rows), "source_files": {}}
+        for name, path in present:
+            meta = metadata[name]
+            cols = gene_columns(meta["gene_ids"], ids)
+            counts = stream_selected_npz(path, g_rows, cols)
+            rng = np.random.default_rng(POISSON_SEED)
+            counts = rng.poisson(counts).astype(np.float32)
+            Gp = pca.transform(cp10k_log1p(counts)).astype(np.float32)
+            result = score_pc(Rp, Gp)
+            rows_out.append({"family": family, "method": name, "n_genes": len(ids),
+                             "n_donors": len(sample_ids), "real_cells": len(r1),
+                             "candidate_cells": len(g_rows), "local_k": 10, **result})
+            f_receipt["source_files"][name] = {"path": str(path), "size_bytes": path.stat().st_size,
+                "mtime_ns": path.stat().st_mtime_ns, "gene_ids_sha256": sha_array(np.asarray(meta["gene_ids"], dtype="S20")),
+                "selected_poisson_counts_sha256": sha_array(counts), "generation": meta["generation"]}
+            print(f"{family}/{name}: coverage={result['coverage']:.4f} precision={result['precision']:.4f}", flush=True)
+        receipt["families"][family] = f_receipt
+    if not rows_out:
+        raise ValueError("no complete family available for rescoring")
+    pd.DataFrame(rows_out).to_csv(output_csv, index=False)
+    output_json.write_text(json.dumps(receipt, indent=2) + "\n")
+    write_legacy_architecture_snapshot()
+    return rows_out, receipt
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--plan", action="store_true")
+    parser.add_argument("--family", action="append", choices=list(family_specs()))
+    parser.add_argument("--per-donor", type=int, default=100)
+    args = parser.parse_args(argv)
+    if args.plan:
+        print(json.dumps(plan(), indent=2)); return 0
+    execute(args.per_donor, args.family or list(family_specs()))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/run_scsemi_strict.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Opt-in strict support guard around the byte-identical legacy scSemi runner.
+
+Pass the legacy runner arguments plus --support-manifest PATH. The n support
+representatives select their own HVG; any reuse/link path is rejected.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+PLAN = Path(__file__).resolve().parents[1]
+M8 = PLAN.parents[1]
+OLD = M8 / "plans/paired_finetune_intradataset_20260927"
+
+
+def _sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        for block in iter(lambda: stream.read(16 * 1024 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def validate_strict_inputs(support_path: Path, work: Path, *, phase: str,
+                           reuse_from: Path | None) -> dict:
+    if reuse_from is not None or phase == "link":
+        raise ValueError("strict scSemi requires own n-support HVG/pretraining; reuse and link are forbidden")
+    inputs = json.loads((Path(work) / "inputs/inputs_manifest.json").read_text())
+    if inputs.get("mode") != "strict" or inputs.get("smoke"):
+        raise ValueError("work inputs are not a full strict-support split")
+    cohort = inputs["dataset"]
+    folds = pd.read_csv(OLD / "data" / cohort / "folds.csv", dtype={"sample_id": str, "donor_id": str})
+    sys.path.insert(0, str(PLAN / "tools"))
+    from support_manifest import load_manifest
+    support = load_manifest(support_path, folds)
+    reps = [r["sample_id"] for r in inputs["representatives"]]
+    if (cohort != support["cohort"] or inputs.get("support_sha256") != support["sha256"] or
+            reps != support["train_sample_ids"] or inputs.get("targets") != support["test_sample_ids"] or
+            inputs.get("train_donors") != support["train_donor_ids"] or
+            inputs.get("sources", {}).get("support.json") != _sha(support_path)):
+        raise ValueError("scSemi inputs differ from exact strict support IDs/hash")
+    if "n_representatives" in inputs and inputs["n_representatives"] != support["n_pairs"]:
+        raise ValueError("scSemi representative budget differs from support")
+    return support
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    ap = argparse.ArgumentParser(description=__doc__, add_help=False)
+    ap.add_argument("--support-manifest", type=Path, required=True)
+    ap.add_argument("--work", type=Path, required=True)
+    ap.add_argument("--phase", required=True)
+    ap.add_argument("--reuse-from", type=Path)
+    known, _ = ap.parse_known_args(args)
+    validate_strict_inputs(known.support_manifest, known.work, phase=known.phase,
+                           reuse_from=known.reuse_from)
+    stripped = []
+    skip = False
+    for token in args:
+        if skip:
+            skip = False
+            continue
+        if token == "--support-manifest":
+            skip = True
+            continue
+        if token.startswith("--support-manifest="):
+            continue
+        stripped.append(token)
+    script = OLD / "scsemi/tools/run_scsemi_paired.py"
+    spec = importlib.util.spec_from_file_location("legacy_scsemi_runner", script)
+    runner = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = runner
+    spec.loader.exec_module(runner)
+    return runner.main(stripped)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/runtime.py

@@ -0,0 +1,203 @@
+"""Bounded, receipt-bound execution; never retries failed scientific operations."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import time
+
+
+class ReceiptError(RuntimeError):
+    """An output cannot be attributed safely to the requested operation."""
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def stamp() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def atomic_json(path: Path, value: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + f".tmp-{os.getpid()}")
+    tmp.write_text(json.dumps(value, indent=2, allow_nan=False) + "\n")
+    tmp.replace(path)
+
+
+def stat_record(path: Path) -> dict:
+    st = path.stat()
+    return {"path": str(path.resolve()), "bytes": st.st_size, "mtime_ns": st.st_mtime_ns}
+
+
+class Runtime:
+    def __init__(self, root: Path):
+        self.root = root.resolve()
+        self.started_at = stamp()
+        (self.root / "receipts").mkdir(parents=True, exist_ok=True)
+        (self.root / "logs").mkdir(parents=True, exist_ok=True)
+        self._guard_restarted = False
+
+    def receipt_path(self, name: str) -> Path:
+        if not re.fullmatch(r"[A-Za-z0-9_.-]+", name):
+            raise ValueError(f"invalid operation name {name!r}")
+        return self.root / "receipts" / f"{name}.json"
+
+    def event(self, name: str, state: str, **details) -> None:
+        record = {"at": stamp(), "operation": name, "state": state, **details}
+        with (self.root / "events.jsonl").open("a") as stream:
+            stream.write(json.dumps(record, allow_nan=False) + "\n")
+        print(f"{record['at']} {name}: {state}", flush=True)
+
+    def signature(self, argv: list[str], inputs: list[Path]) -> str:
+        value = {"argv": [str(x) for x in argv], "inputs": [
+            {"path": str(p.resolve()), "sha256": sha256(p)} for p in inputs]}
+        return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+    def write_receipt(self, name: str, value: dict) -> None:
+        atomic_json(self.receipt_path(name), value)
+
+    def can_skip(self, name: str, signature: str, outputs: list[Path],
+                 previous_outputs: dict | None = None) -> bool:
+        receipt = self.receipt_path(name)
+        if not receipt.exists():
+            for p in outputs:
+                if not p.exists():
+                    continue
+                prior = (previous_outputs or {}).get(str(p))
+                if (not prior or p.suffix in (".npz", ".pt", ".pth", ".safetensors") or
+                        not p.resolve().is_relative_to(self.root)):
+                    raise ReceiptError(f"{name}: unreceipted output exists; preserve and inspect")
+                backup = Path(prior["backup"])
+                if (not backup.is_file() or backup.resolve() == p.resolve() or
+                        sha256(p) != prior["sha256"] or sha256(backup) != prior["sha256"]):
+                    raise ReceiptError(f"{name}: preview replacement is not bound to a preserved copy")
+            return False
+        record = json.loads(receipt.read_text())
+        if record.get("state") != "completed":
+            raise ReceiptError(f"{name}: previous {record.get('state')}; inspect before explicit recovery")
+        if record.get("signature") != signature:
+            raise ReceiptError(f"{name}: scientific inputs or command changed; use a new version")
+        old = record.get("outputs", [])
+        if len(old) != len(outputs):
+            raise ReceiptError(f"{name}: output contract changed")
+        for p, expected in zip(outputs, old):
+            if not p.is_file() or stat_record(p) != {k: expected[k] for k in ("path", "bytes", "mtime_ns")}:
+                raise ReceiptError(f"{name}: output missing or modified: {p}")
+            if sha256(p) != expected.get("sha256"):
+                raise ReceiptError(f"{name}: output hash changed: {p}")
+        return True
+
+    def record_completed(self, name: str, signature: str, outputs: list[Path], seconds: float) -> None:
+        records = []
+        for path in outputs:
+            if not path.is_file() or path.stat().st_size == 0:
+                raise ReceiptError(f"{name}: missing or empty required output {path}")
+            records.append({**stat_record(path), "sha256": sha256(path)})
+        self.write_receipt(name, {"state": "completed", "signature": signature,
+                                  "outputs": records, "seconds": seconds, "at": stamp()})
+
+    def wrapped_command(self, name: str, argv: list[str], resource: str,
+                        memory_gib: int, threads: int) -> list[str]:
+        if resource not in ("cpu", "gpu"):
+            raise ValueError("resource must explicitly be cpu or gpu")
+        if not 1 <= threads <= 8 or not 1 <= memory_gib <= 64:
+            raise ValueError("unsafe CPU/memory budget")
+        env = ["PATH=/home/sj_server_1/.local/bin:/home/sj_server_1/miniforge3/bin:/usr/local/bin:/usr/bin:/bin",
+               "PYTHONDONTWRITEBYTECODE=1", "PYTHONUNBUFFERED=1", f"OMP_NUM_THREADS={threads}",
+               f"OPENBLAS_NUM_THREADS={threads}", f"MKL_NUM_THREADS={threads}",
+               f"NUMBA_NUM_THREADS={threads}"]
+        if resource == "gpu":
+            return ["/home/sj_server_1/.local/bin/ml-run", "/usr/bin/env", "CUDA_VISIBLE_DEVICES=0",
+                    "PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True", *env, *map(str, argv)]
+        unit = f"pbisc-strict-{name[:100]}-{os.getpid()}-{time.time_ns()}"
+        return ["systemd-run", "--user", "--wait", "--collect", "--pipe", "--quiet",
+                f"--unit={unit}", "--slice=app.slice", f"--working-directory={self.root}",
+                "--expand-environment=no", "-p", f"MemoryMax={memory_gib}G", "-p", "MemorySwapMax=0",
+                "-p", "OOMPolicy=kill", "-p", "OOMScoreAdjust=500", "-p", f"CPUQuota={threads * 100}%",
+                "/usr/bin/env", "CUDA_VISIBLE_DEVICES=", *env, *map(str, argv)]
+
+    def preflight(self, resource: str, memory_gib: int) -> None:
+        # Every substantial CPU operation and every CUDA operation checks all three controls.
+        active = subprocess.run(["systemctl", "--user", "is-active", "ml-memory-guard.service"],
+                                capture_output=True, text=True)
+        if active.returncode:
+            if not self._guard_restarted:
+                self._guard_restarted = True
+                subprocess.run(["systemctl", "--user", "restart", "ml-memory-guard.service"], check=True)
+            subprocess.run(["systemctl", "--user", "is-active", "ml-memory-guard.service"], check=True)
+        subprocess.run(["/home/sj_server_1/.local/libexec/ml-memory-guard", "--check"], check=True)
+        compute = subprocess.run(["nvidia-smi", "--query-compute-apps=pid,process_name,used_memory",
+                                  "--format=csv,noheader"], capture_output=True, text=True, check=True)
+        guard_log = subprocess.run(["journalctl", "-t", "ml-memory-guard", "--since", self.started_at,
+                                    "--no-pager"], capture_output=True, text=True, check=True)
+        if "stopping ml.slice" in guard_log.stdout:
+            raise RuntimeError("memory guard stopped ml.slice; inspect evidence before any restart")
+        available = next(int(line.split()[1]) / 1048576 for line in Path("/proc/meminfo").read_text().splitlines()
+                         if line.startswith("MemAvailable:"))
+        floor = max(32, memory_gib + 24) if resource == "cpu" else 48
+        if shutil.disk_usage(self.root).free < 64 * 2**30:
+            raise BlockingIOError("less than 64 GiB free disk; preserve originals and wait for storage")
+        if available < floor:
+            raise BlockingIOError(f"MemAvailable {available:.1f} GiB below {floor} GiB launch floor")
+        if resource == "gpu":
+            if compute.stdout.strip():
+                raise BlockingIOError("another CUDA process is active")
+            lock = subprocess.run(["flock", "--nonblock", "/run/user/1000/ml-gpu0.lock", "true"])
+            if lock.returncode:
+                raise BlockingIOError("shared GPU lock is held")
+
+    def execute(self, name: str, argv: list[str], *, resource: str = "cpu", memory_gib: int = 16,
+                threads: int = 4, inputs: list[Path] | None = None,
+                outputs: list[Path] | None = None, wait_seconds: int = 86400,
+                previous_outputs: dict | None = None) -> bool:
+        inputs, outputs = inputs or [], outputs or []
+        signature = self.signature(argv, inputs)
+        if self.can_skip(name, signature, outputs, previous_outputs=previous_outputs):
+            self.event(name, "verified_skip")
+            return False
+        wait_start, announced = time.monotonic(), False
+        while True:
+            try:
+                self.preflight(resource, memory_gib)
+                break
+            except BlockingIOError as exc:
+                if not announced:
+                    self.event(name, "waiting_resources", reason=str(exc))
+                    announced = True
+                if time.monotonic() - wait_start > wait_seconds:
+                    raise TimeoutError(str(exc)) from exc
+                time.sleep(15)
+        command = self.wrapped_command(name, argv, resource, memory_gib, threads)
+        self.write_receipt(name, {"state": "running", "signature": signature, "argv": argv,
+                                  "resource": resource, "at": stamp(), "previous_outputs": previous_outputs})
+        self.event(name, "running", resource=resource)
+        t0 = time.monotonic()
+        try:
+            with (self.root / "logs" / f"{name}.log").open("a") as log:
+                result = subprocess.run(command, cwd=self.root, stdout=log, stderr=subprocess.STDOUT)
+            elapsed = time.monotonic() - t0
+            if result.returncode:
+                raise subprocess.CalledProcessError(result.returncode, command)
+            self.record_completed(name, signature, outputs, elapsed)
+            if previous_outputs:
+                receipt = json.loads(self.receipt_path(name).read_text())
+                receipt["previous_outputs"] = previous_outputs
+                self.write_receipt(name, receipt)
+        except BaseException as exc:
+            self.write_receipt(name, {"state": "failed", "signature": signature, "at": stamp(),
+                                      "error": str(exc), "seconds": time.monotonic() - t0})
+            self.event(name, "failed", error=str(exc))
+            raise
+        self.event(name, "completed", seconds=elapsed)
+        return True