Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/aggregate_k4000.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""LoRA-5 at K = 4,000 vs K = 1,000 on the paired benchmark, over the five few-pair draws (CPU only; 2026-10-06).
+
+Reads scores/<ds>/draw<j>/ (tools/score_paired.sh: the benchmark scorer, both arms in one call, the draw's test
+donors) and writes analysis/benchmark/<ds>/{AGGREGATE.md, aggregate.json, per_draw.csv}:
+  * per arm, mean +- SD over draws of the benchmark headline metrics (as aggregate_fewshot.py: composition L1,
+    precision, coverage, coverage depth-matched, pseudobulk r, monocyte %, top-50 DEG overlap and its broadcast
+    analogue) and of the case-vs-control per-cell-type logFC agreement (mean_cp10k, mean of T/B/Mono/NK: r generated,
+    r bulk broadcast, partial r given broadcast)
+  * paired comparisons over draws (K = 4,000 minus K = 1,000; the same draw = the same training donors and test
+    donors) and per donor-draw for composition L1 (Wilcoxon)
+  * a scorer check: this plan's lora5 arm against the benchmark's stored draw scores
+    (paired_finetune_intradataset_20260927/scores/<ds>/fewshot_n5/draw<j>/summary.json), max |difference|
+usage: CUDA_VISIBLE_DEVICES='' aggregate_k4000.py DATASET
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+from scipy.stats import wilcoxon
+
+PLAN = Path(__file__).resolve().parents[1]
+FT = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+ARMS = ("lora5", "lora5_k4000")
+LABEL = {"lora5": "LoRA-5, K = 1,000 (benchmark)", "lora5_k4000": "LoRA-5, K = 4,000"}
+M = ["comp_l1", "precision", "coverage", "coverage_dm", "pb_r_median", "mono_pct_gen", "mono_pct_obs",
+     "median_umi_gen", "median_umi_obs", "deg_top50_sum", "deg_top50_sum_broadcast"]
+TYPES4 = ("T cell", "B cell", "Monocyte", "NK cell")
+
+
+def main(argv=None) -> int:
+    ds = (argv or sys.argv[1:])[0]
+    root = PLAN / "scores" / ds
+    draws = sorted((p for p in root.glob("draw*") if (p / "summary.json").exists()), key=lambda p: int(p.name[4:]))
+    rows, per, check = [], [], {}
+    for dd in draws:
+        s = json.loads((dd / "summary.json").read_text())
+        c = pd.read_csv(dd / "contrast.csv")
+        c = c[(c.statistic == "mean_cp10k") & c.celltype.isin(TYPES4)]
+        for arm in ARMS:
+            h = s["headline"][arm]
+            ca = c[c.arm == arm]
+            rows.append({"draw": int(dd.name[4:]), "arm": arm, **{m: h.get(m) for m in M},
+                         "logfc_r_gen": float(ca.r_generated.mean()), "logfc_r_broadcast": float(ca.r_broadcast.mean()),
+                         "logfc_partial_r": float(ca.partial_r_generated_given_broadcast.mean()),
+                         **{f"logfc_r_{t.split()[0]}": float(ca.loc[ca.celltype == t, "r_generated"].iloc[0])
+                            for t in TYPES4 if (ca.celltype == t).any()}})
+        p = pd.read_csv(dd / "per_donor.csv")
+        p["draw"] = int(dd.name[4:])
+        per.append(p)
+        ref = FT / "scores" / ds / "fewshot_n5" / dd.name / "summary.json"
+        if ref.exists():
+            rh = json.loads(ref.read_text())["headline"]["lora5"]
+            mine = s["headline"]["lora5"]
+            diffs = [abs(float(mine[k]) - float(rh[k])) for k in rh if k in mine and k != "seconds"
+                     and isinstance(rh[k], (int, float)) and isinstance(mine[k], (int, float))
+                     and np.isfinite(float(rh[k])) and np.isfinite(float(mine[k]))]
+            check[dd.name] = {"metrics_compared": len(diffs), "max_abs_diff": max(diffs) if diffs else None}
+    df = pd.DataFrame(rows)
+    out_dir = PLAN / "analysis" / "benchmark" / ds
+    out_dir.mkdir(parents=True, exist_ok=True)
+    df.to_csv(out_dir / "per_draw.csv", index=False)
+    cols = M + ["logfc_r_gen", "logfc_r_broadcast", "logfc_partial_r"]
+    out = {"dataset": ds, "draws": sorted(df.draw.unique().tolist()), "arms": {}, "paired_over_draws": {},
+           "scorer_check_vs_benchmark": check}
+    lines = [f"# {ds}: LoRA-5 at K = 4,000 vs K = 1,000 on the paired benchmark ({len(draws)} draws)", "",
+             "Same five few-pair draws (same 5 training donors each), same test donors, same scorer "
+             "(paired_finetune_intradataset_20260927/tools/score_ft.py), 1,500 cells per test sample. Mean ± SD over draws.",
+             "", "| metric | " + " | ".join(LABEL[a] for a in ARMS) + " | K4000 − K1000 (draws better / n) |",
+             "|---|---:|---:|---|"]
+    lower_better = {"comp_l1"}
+    closer_better = {"mono_pct_gen": "mono_pct_obs", "median_umi_gen": "median_umi_obs"}
+    for m in cols:
+        w = df.pivot(index="draw", columns="arm", values=m).astype(float)
+        if w[list(ARMS)].isna().all().any():
+            continue
+        diff = w["lora5_k4000"] - w["lora5"]
+        if m in closer_better:      # better = closer to the observed value of the same draw's test donors
+            o = df.pivot(index="draw", columns="arm", values=closer_better[m]).astype(float)["lora5"]
+            better = int(((w["lora5_k4000"] - o).abs() < (w["lora5"] - o).abs()).sum())
+        else:
+            better = int((diff < 0).sum()) if m in lower_better else int((diff > 0).sum())
+        out["paired_over_draws"][m] = {"mean_diff": float(diff.mean()), "draws_better": better, "n": int(diff.notna().sum())}
+        for a in ARMS:
+            out["arms"].setdefault(a, {})[m] = [float(w[a].mean()), float(w[a].std(ddof=1)) if len(w) > 1 else None]
+        cell = " | ".join(f"{w[a].mean():.3f} ± {w[a].std(ddof=1):.3f}" if len(w) > 1 else f"{w[a].mean():.3f}" for a in ARMS)
+        tag = "" if m in ("mono_pct_obs", "median_umi_obs", "logfc_r_broadcast", "deg_top50_sum_broadcast") \
+            else f"{better} / {int(diff.notna().sum())}"
+        lines.append(f"| {m} | {cell} | {diff.mean():+.3f} ({tag}) |" if tag else f"| {m} | {cell} | {diff.mean():+.3f} |")
+    pp = pd.concat(per)
+    w = pp.pivot_table(index=["draw", "donor"], columns="arm", values="comp_l1")
+    x = (w["lora5_k4000"] - w["lora5"]).dropna()
+    if len(x) > 0:
+        wp = float(wilcoxon(x).pvalue) if (x != 0).any() else float("nan")
+        out["comp_l1_per_donor_draw"] = {"mean_diff": float(x.mean()), "frac_k4000_better": float((x < 0).mean()),
+                                         "wilcoxon_p": wp, "n": int(len(x))}
+        lines += ["", f"Per donor-draw composition L1, K = 4,000 − K = 1,000: {x.mean():+.4f}; K = 4,000 is better in "
+                      f"{(x < 0).mean():.0%} of {len(x)} donor-draws (Wilcoxon p {wp:.2g})."]
+    lines += ["", "Lower is better for comp_l1; closer to *_obs is better for mono_pct_gen and median_umi_gen; higher is "
+                  "better for precision, coverage, pseudobulk r, the logFC r values and the top-50 DEG overlap. *_obs and "
+                  "*broadcast rows are the same for both arms (observed truth / bulk baseline).",
+              "", "Scorer check: this plan's K = 1,000 arm vs the benchmark's stored draw scores, max |difference| per draw: "
+              + ", ".join(f"{k} {v['max_abs_diff']:.2g} ({v['metrics_compared']} metrics)" for k, v in check.items()
+                          if v["max_abs_diff"] is not None) + "."]
+    (out_dir / "AGGREGATE.md").write_text("\n".join(lines) + "\n")
+    (out_dir / "aggregate.json").write_text(json.dumps(out, indent=1) + "\n")
+    print("\n".join(lines))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/annotate_bulkonly.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Label the K = 4,000 bulk-only cells of one draw and reduce them to the compact files (CPU only; tools/common.py).
+
+Adapted from plans/bulkonly_lora5_20261006/tools/annotate_bulkonly.py (2026-10-06).  Differences:
+  input    the draw's row parts: generated/<ds>/draw<j>/bulkonly_K4000_part<k>.npz + .log receipt, one per part of
+           data/<ds>/bulkonly_raw_K4000.PARTS.json; each NPZ sha must equal its receipt, the receipt's condition sha
+           the part file, its seed the queue seed (PARTS.json seed + draw x 1,000,003), and every part the checkpoint
+           of runs/<ds>/draw<j>/lora_k4000/RUN.json
+  read-out ONE Poisson read-out over the whole set (all parts in row order, one generator; common.poisson_over_parts =
+           poisson_integerise of the unsplit matrix) with seed 20260916 + draw (common.bulkonly_poisson_seed), so the
+           draws do not share read-out noise
+The annotator is unchanged: frozen f01common scANVI (ft_common.run_annotator: predict_scanvi.py, CPU), query genes and
+zero-pad contract of the cohort's scoring reference, sample key "<sample>|generated".
+Output: work/<ds>/bulkonly/draw<j>/{cells.parquet, markers.npz, pb_l2.npz, pb_l1.npz, subsample.npz, RECEIPT.json,
+        labels/, predict_scanvi.log}
+usage: CUDA_VISIBLE_DEVICES='' annotate_bulkonly.py DATASET DRAW [--threads 8]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import common as C  # noqa: E402
+F = C.F
+DRAW_STRIDE = 1_000_003          # tools/make_queue.py
+K = 4000
+
+
+def bulkonly_units(ds: str, j: int) -> tuple[list[dict], str]:
+    """The draw's parts in row order with every receipt check done; returns (units, checkpoint sha256)."""
+    man = json.loads((C.PLAN / "data" / ds / f"bulkonly_raw_K{K}.PARTS.json").read_text())
+    run = json.loads((C.PLAN / "runs" / ds / f"draw{j}" / f"lora_k{K}" / "RUN.json").read_text())
+    gdir = C.PLAN / "generated" / ds / f"draw{j}"
+    units = []
+    for p in man["parts"]:
+        npz = gdir / f"bulkonly_K{K}_part{p['part']}.npz"
+        cond = C.PLAN / "data" / ds / p["file"]
+        rec = json.loads(npz.with_suffix(".log").read_text())
+        got = C.sha(npz)
+        if got != rec["output_sha256"]:
+            raise SystemExit(f"{npz.name}: sha {got[:12]} != receipt {rec['output_sha256'][:12]}")
+        if C.sha(cond) != rec.get("condition_sha256") or rec.get("condition_sha256") != p["sha256"]:
+            raise SystemExit(f"{npz.name}: receipt condition sha differs from {cond.name} / PARTS.json")
+        if int(rec["seed"]) != int(p["seed"]) + j * DRAW_STRIDE:
+            raise SystemExit(f"{npz.name}: seed {rec['seed']} != queue seed {int(p['seed']) + j * DRAW_STRIDE}")
+        if rec.get("checkpoint_sha256") != run["checkpoint_sha256"]:
+            raise SystemExit(f"{npz.name}: checkpoint sha differs from RUN.json")
+        units.append({"part": p["part"], "rows": p["rows"], "npz": str(npz), "npz_sha256": got, "condition": str(cond),
+                      "condition_sha256": rec["condition_sha256"], "seed": int(rec["seed"]),
+                      "checkpoint": rec.get("checkpoint"), "checkpoint_sha256": rec["checkpoint_sha256"],
+                      "cells": int(rec["cells"])})
+    return units, run["checkpoint_sha256"]
+
+
+def sample_of_cells(units: list[dict], cells_expected: int) -> np.ndarray:
+    out = []
+    for u in units:
+        d = np.load(u["npz"], allow_pickle=False)
+        sid = d["sample_ids"].astype(str)
+        bi = d["bulk_index"].astype(np.int64)
+        if not (np.bincount(bi, minlength=len(sid)) == cells_expected).all():
+            raise SystemExit(f"{u['npz']}: not {cells_expected} cells for every sample")
+        out.append(sid[bi])
+    return np.concatenate(out)
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("dataset")
+    ap.add_argument("draw", type=int)
+    ap.add_argument("--threads", type=int, default=8)
+    a = ap.parse_args(argv)
+    try:
+        from threadpoolctl import threadpool_limits
+        threadpool_limits(a.threads)
+    except ImportError:
+        pass
+    t0 = time.monotonic()
+    ds, j = a.dataset, a.draw
+    units, ck_sha = bulkonly_units(ds, j)
+    samples = sample_of_cells(units, 4000)
+    meta = pd.read_csv(C.PLAN / "data" / ds / "bulkonly_meta.csv")
+    order = pd.unique(samples)
+    if list(order) != meta.sample_id.astype(str).tolist():
+        raise SystemExit("generated sample order differs from bulkonly_meta.csv")
+    ps = C.panel_setup(ds)
+    for u in units:
+        d = np.load(u["npz"], allow_pickle=False)
+        if not np.array_equal(d["gene_ids"].astype(str), ps["panel"]):
+            raise SystemExit("NPZ gene_ids differ from the 6k panel")
+    seed = C.bulkonly_poisson_seed(j)
+    X = C.poisson_over_parts([Path(u["npz"]) for u in units], seed=seed)
+    if X.shape[0] != samples.size:
+        raise SystemExit("read-out rows differ from the cells")
+    ref, man = F.load_reference(F.CACHE_ROOT / ds)
+    ppos = {g: i for i, g in enumerate(ps["panel"])}
+    qidx = np.asarray([ppos[g] for g in ref["query_ids"].astype(str)], dtype=np.int64)
+    work = C.PLAN / "work" / ds / "bulkonly" / f"draw{j}"
+    lab, linfo = F.run_annotator(X[:, qidx], list(ref["query_ids"].astype(str)),
+                                 np.asarray([f"{s}|generated" for s in samples], dtype=object), work=work,
+                                 method=f"lora5k4_bulkonly_d{j}", spec=F.DATASETS[ds], split="generated",
+                                 threads=a.threads, annot=F.annotator_run(None),
+                                 expected_zero_pad=man["gene_sets"]["model_genes_missing_from_query"],
+                                 source_note={"kind": "generated_npz_parts", "readout": "poisson", "seed": seed,
+                                              "source_path": ";".join(u["npz"] for u in units),
+                                              "source_sha256": ";".join(u["npz_sha256"] for u in units),
+                                              "poisson_note": "one read-out over all parts in row order, one generator"})
+    receipt = {"set": "bulkonly", "version": f"K{K}", "dataset": ds, "draw": j, "generated": units,
+               "npz_rows": int(X.shape[0]), "checkpoint_sha256": ck_sha, "poisson_seed": seed,
+               "poisson_rule": "one read-out over the whole set (parts in row order, one generator), seed 20260916 + draw",
+               "annotation": {k: linfo[k] for k in ("model_pt_sha256", "zero_padded_model_genes", "label_counts",
+                                                    "mean_l2_max_prob", "predict_seconds")},
+               "tool": str(Path(__file__).resolve()), "tool_sha256": C.sha(Path(__file__)),
+               "common_sha256": C.sha(Path(C.__file__))}
+    out = C.write_compact(work, X, samples, lab, ps, receipt)
+    out["seconds"] = round(time.monotonic() - t0, 1)
+    (work / "RECEIPT.json").write_text(json.dumps(out, indent=1, default=str) + "\n")
+    print(json.dumps({k: out[k] for k in ("dataset", "draw", "cells", "samples", "seconds")} |
+                     {"labels_l1": out["annotation"]["label_counts"]}, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/build_archive_request.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""PBISC-Diffusion archive request for one bulk-only LoRA-5 plan (CPU only; 2026-10-06).
+
+paper-release-20260928/maintenance/POLICY.md: exact changed assets with provenance; inference outputs as locations
+plus receipts and hashes (never payload); checkpoints as `checkpoint` assets on the host that holds them.
+For PLAN (bulkonly_lora5_20261006 or bulkonly_lora5_k4000_20261006) it lists:
+  code      tools/*.py, tools/*.sh
+  document  README.md, share/README.md, analysis/DATA_GUIDE.md, analysis/wf/REPORT_*.md
+  report    analysis/benchmark/<ds>/AGGREGATE.md, analysis/compare_k1000/<ds>/SUMMARY.md (K = 4,000 plan)
+  metadata  data/<ds>/*.json, data/<ds>/bulkonly_meta.csv, data/<ds>/paired_test/*.json, queues/*, share/MANIFEST.json,
+            share/SHA256SUMS, runs/<ds>/draw<j>/lora_k4000/RUN.json
+  condition data/<ds>/*.npz, data/<ds>/paired_test/*.npz
+  table     analysis/features/<ds>/*, analysis/wf/findings_*.json, analysis/benchmark/<ds>/*.{csv,json},
+            analysis/compare_k1000/<ds>/per_feature.csv, scores/<ds>/draw<j>/{summary.json,per_donor.csv,contrast.csv}
+  data      share_stage/analysis/analysis_bundle.tar.gz (every analysis agent's scripts and tables)
+  log       logs/*.log, runs/<ds>/draw<j>/lora_k4000/{train.log,history.json}
+  checkpoint runs/<ds>/draw<j>/lora_k4000/checkpoint_ft.pt on the host where it exists (sha = RUN.json)
+inference_locations: every generated NPZ with its receipt (sha256, checkpoint, condition, seed), the shared h5ad
+files (sha256 from share/SHA256SUMS) and the R2 share prefix.  Only files that exist are listed; nothing is hashed
+twice (receipt sha256 values are taken from the receipts and re-checked here for NPZs on this host).
+usage: build_archive_request.py PLAN_DIR OUT_JSON "summary text"
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def remote_exists(path: Path) -> bool:
+    return subprocess.run(["ssh", "-n", "-o", "BatchMode=yes", "spark-0110", f"test -s '{path}'"]).returncode == 0
+
+
+def main(argv=None) -> int:
+    plan, out, summary = Path(sys.argv[1]).resolve(), Path(sys.argv[2]), sys.argv[3]
+    assets, locs = [], []
+
+    def add(kind: str, paths, host: str = "server_1") -> None:
+        for p in sorted(set(paths)):
+            if p.is_file() and "__pycache__" not in p.parts and ".bak" not in p.name and not p.name.endswith(".new"):
+                assets.append({"host": host, "kind": kind, "source": str(p), "state": "completed"})
+
+    add("code", list(plan.glob("tools/*.py")) + list(plan.glob("tools/*.sh")))
+    add("document", [plan / "README.md", plan / "share/README.md", plan / "analysis/DATA_GUIDE.md",
+                     *plan.glob("analysis/wf/REPORT_*.md")])
+    add("report", list(plan.glob("analysis/benchmark/*/AGGREGATE.md")) + list(plan.glob("analysis/compare_k1000/*/SUMMARY.md")))
+    add("metadata", [*plan.glob("data/*/*.json"), *plan.glob("data/*/bulkonly_meta.csv"),
+                     *plan.glob("data/*/paired_test/*.json"), *plan.glob("queues/*"), plan / "share/MANIFEST.json",
+                     plan / "share/SHA256SUMS", *plan.glob("runs/*/draw*/lora_k4000/RUN.json")])
+    add("condition", list(plan.glob("data/*/*.npz")) + list(plan.glob("data/*/paired_test/*.npz")))
+    add("table", [*plan.glob("analysis/features/*/*"), *plan.glob("analysis/wf/findings_*.json"),
+                  *plan.glob("analysis/benchmark/*/*.csv"), *plan.glob("analysis/benchmark/*/*.json"),
+                  *plan.glob("analysis/compare_k1000/*/per_feature.csv"),
+                  *[f for d in plan.glob("scores/*/draw*") for f in (d / "summary.json", d / "per_donor.csv", d / "contrast.csv")]])
+    add("data", [plan / "share_stage/analysis/analysis_bundle.tar.gz"])
+    add("log", [*plan.glob("logs/*.log"), *plan.glob("runs/*/draw*/lora_k4000/train.log"),
+                *plan.glob("runs/*/draw*/lora_k4000/history.json")])
+    for rj in sorted(plan.glob("runs/*/draw*/lora_k4000/RUN.json")):
+        ck = rj.parent / "checkpoint_ft.pt"
+        if ck.is_file():
+            if sha(ck) != json.loads(rj.read_text())["checkpoint_sha256"]:
+                raise SystemExit(f"{ck}: sha differs from RUN.json")
+            assets.append({"host": "server_1", "kind": "checkpoint", "source": str(ck), "state": "completed"})
+        elif remote_exists(ck):
+            assets.append({"host": "server_2", "kind": "checkpoint", "source": str(ck), "state": "completed"})
+        else:
+            raise SystemExit(f"{ck}: on neither host")
+    for npz in sorted(plan.glob("generated/*/draw*/*.npz")):
+        rec_p = npz.with_suffix(".log")
+        rec = json.loads(rec_p.read_text())
+        if sha(npz) != rec["output_sha256"]:
+            raise SystemExit(f"{npz}: sha differs from its receipt")
+        ds, draw = npz.parts[-3], npz.parts[-2]
+        locs.append({"artifact_role": "inference_output", "experiment": plan.name, "cohort": ds, "draw": draw,
+                     "host": "server_1", "path": str(npz), "sha256": rec["output_sha256"],
+                     "output_sha256": rec["output_sha256"], "receipt": str(rec_p),
+                     "checkpoint": rec.get("checkpoint"), "checkpoint_sha256": rec.get("checkpoint_sha256"),
+                     "condition_npz": rec.get("condition_npz"), "condition_sha256": rec.get("condition_sha256"),
+                     "seed": rec.get("seed"), "steps": rec.get("steps"), "cells": rec.get("cells"),
+                     "state": "completed"})
+    sums = {}
+    if (plan / "share/SHA256SUMS").exists():
+        for line in (plan / "share/SHA256SUMS").read_text().splitlines():
+            h, p = line.split(None, 1)
+            sums[p.strip()] = h
+    for h5 in sorted(plan.glob("share/*/*.h5ad")):
+        rel = str(h5.relative_to(plan / "share"))
+        locs.append({"artifact_role": "shared_cells_h5ad", "experiment": plan.name, "cohort": h5.parts[-2],
+                     "host": "server_1", "path": str(h5), "sha256": sums.get(rel) or sha(h5),
+                     "receipt": str(plan / "share/MANIFEST.json"), "state": "completed"})
+    # the R2 share (private bucket) is recorded in the plan README and the request summary: the archive tool takes
+    # only server_1 / server_2 locations
+    req = {"project_id": "pbisc-diffusion", "summary": summary, "assets": assets, "inference_locations": locs}
+    out.write_text(json.dumps(req, indent=1) + "\n")
+    kinds = {}
+    for a in assets:
+        kinds[a["kind"]] = kinds.get(a["kind"], 0) + 1
+    print(json.dumps({"assets": len(assets), "by_kind": kinds, "inference_locations": len(locs)}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/build_k_conditions.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Real-bulk conditions at recipe size K for the K = 4,000 version of the bulk-only LoRA-5 study (CPU only; 2026-10-06).
+
+User request (2026-10-06): after the K = 1,000 version (plans/bulkonly_lora5_20261006), retrain the LoRA-5 models at
+K = 4,000, generate 4,000 cells per bulk-only sample, and share it through R2 like the first version.
+
+K is the recipe size of the condition, not a cell number: counts = CPM(bulk on its measured genes) / 1e6 x K x
+DEPTH_ANCHOR and recipe_k = K, i.e. build_realbulk_conditions.to_condition_counts with RECIPE_K replaced by K (as in
+behcet_c1q_lora3_20261004/tools/build_k_conditions.py).
+
+Per cohort three condition sets.  Each is first rebuilt at K = 1,000 and must equal, byte for byte, the file it is
+derived from (bulk_counts, measurement fraction, recipe_k); otherwise nothing is written.
+  training   data/<ds>/conditions_raw_fixed_K<K>.npz  <- FT data/<ds>/conditions_raw_fixed.npz: every row in folds.csv
+             order (what ft_sdd.py --condition-npz needs); bulk = prepare_dataset.load(FT data/<ds>) bulk / bulk_valid
+  paired     data/<ds>/paired_test/draw<j>_test_raw_K<K>.npz  <- FT data/<ds>/fewshot_n5/draw<j>/test_raw.npz: the
+             draw's paired test rows (its dataset_rows of the same bulk), 1,500 cells per sample as in the benchmark,
+             so the K = 4,000 and K = 1,000 LoRA-5 models are compared at equal cell numbers
+  bulk-only  data/<ds>/bulkonly_raw_K<K>.npz  <- bulkonly_lora5_20261006/data/<ds>/bulkonly_raw.npz: the same samples
+             in the same order, --cells-bulkonly cells per sample (4,000); bulk = the harmonized bulk rows read by that
+             plan's build_conditions.read_bulk
+Every other key is copied unchanged; recipe_k = K, arm = "raw_K<K>", cells_per_bulk as stated above.
+Also copies bulkonly_meta.csv (sha checked against the first plan's BUILD.json) and writes data/<ds>/K_BUILD.json.
+usage: CUDA_VISIBLE_DEVICES='' build_k_conditions.py DATASET [--k 4000] [--cells-bulkonly 4000]
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import os
+import shutil
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+PLAN = Path(__file__).resolve().parents[1]
+K1 = M8 / "plans/bulkonly_lora5_20261006"            # the K = 1,000 version
+sys.path.insert(0, str(FT / "tools"))
+import prepare_dataset as PD  # noqa: E402  (load; RB = build_realbulk_conditions)
+RB = PD.RB
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def counts_at(expression: np.ndarray, measured: np.ndarray, k: int) -> np.ndarray:
+    """RB.to_condition_counts (fixed depth) with RECIPE_K replaced by k."""
+    x = np.where(measured, np.asarray(expression, dtype=np.float64), 0.0)
+    return RB.cpm(x) / 1e6 * (k * RB.DEPTH_ANCHOR)
+
+
+def derive(src: Path, out: Path, counts: np.ndarray, k: int, cells_per_bulk: int | None) -> dict:
+    """Copy every key of src; replace bulk_counts, recipe_k, arm (and cells_per_bulk when given)."""
+    base = np.load(src, allow_pickle=True)   # donor_ids / groups are object arrays in these files (benchmark format)
+    arrays = {key: base[key] for key in base.files}
+    if counts.shape != arrays["bulk_counts"].shape:
+        raise SystemExit(f"{src.name}: counts shape {counts.shape} != {arrays['bulk_counts'].shape}")
+    fr = arrays["bulk_measurement_fraction"]
+    if bool((counts[fr == 0] != 0).any()):
+        raise SystemExit(f"{out.name}: unmeasured coordinate with a non-zero count")
+    arrays["bulk_counts"] = counts
+    arrays["recipe_k"] = np.full(len(arrays["recipe_k"]), k, dtype=np.int64)
+    arrays["arm"] = np.array(f"raw_K{k}")
+    if cells_per_bulk is not None:
+        arrays["cells_per_bulk"] = np.full(len(arrays["cells_per_bulk"]), int(cells_per_bulk), dtype=np.int64)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    np.savez(out, **arrays)
+    chk = np.load(out, allow_pickle=True)
+    for key in arrays:
+        if not np.array_equal(chk[key], arrays[key]):
+            raise SystemExit(f"{out.name}: {key} differs after writing")
+    return {"file": str(out), "sha256": sha(out), "source": str(src), "source_sha256": sha(src),
+            "rows": int(counts.shape[0]), "recipe_k": k,
+            "cells_per_bulk": sorted({int(x) for x in arrays["cells_per_bulk"]})}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("dataset", choices=("ye2026_sepsis", "imperial_eskd"))
+    ap.add_argument("--k", type=int, default=4000)
+    ap.add_argument("--cells-bulkonly", type=int, default=4000)
+    a = ap.parse_args(argv)
+    ds, k = a.dataset, a.k
+    if int(RB.RECIPE_K) != 1000:
+        raise SystemExit("build_realbulk_conditions.RECIPE_K is not 1000")
+    ddir = FT / "data" / ds
+    out = PLAN / "data" / ds
+    checks, files = {}, {}
+
+    # ---- training: every row of the dataset
+    d = PD.load(ddir)
+    ref = np.load(ddir / "conditions_raw_fixed.npz", allow_pickle=True)
+    c1 = counts_at(d["bulk"], d["bulk_valid"], 1000)
+    checks["training_K1000_equals_conditions_raw_fixed"] = bool(
+        np.array_equal(c1, ref["bulk_counts"]) and np.array_equal(c1, RB.to_condition_counts(d["bulk"], d["bulk_valid"]))
+        and (ref["recipe_k"] == 1000).all()
+        and np.array_equal(d["bulk_valid"].astype(np.float32), ref["bulk_measurement_fraction"]))
+    ck = counts_at(d["bulk"], d["bulk_valid"], k)
+
+    # ---- paired test rows of every draw
+    draws = json.loads((ddir / "fewshot_n5" / "DRAWS.json").read_text())["draw"]
+    paired = {}
+    for j in sorted(draws, key=int):
+        src = ddir / "fewshot_n5" / f"draw{j}" / "test_raw.npz"
+        t = np.load(src, allow_pickle=True)
+        rows = t["dataset_rows"].astype(np.int64)
+        ok = (np.array_equal(c1[rows], t["bulk_counts"]) and (t["recipe_k"] == 1000).all()
+              and np.array_equal(t["sample_ids"].astype(str), d["sample_ids"][rows])
+              and np.array_equal(d["bulk_valid"][rows].astype(np.float32), t["bulk_measurement_fraction"])
+              and set(t["cells_per_bulk"].tolist()) == {1500})
+        test_ids = [l.strip() for l in (src.parent / "test_samples.txt").read_text().splitlines() if l.strip()]
+        ok = ok and sorted(test_ids) == sorted(t["sample_ids"].astype(str).tolist())
+        checks[f"paired_draw{j}_K1000_equals_test_raw"] = bool(ok)
+        paired[j] = (src, rows)
+
+    # ---- bulk-only samples (the K = 1,000 plan's file, same order)
+    spec = importlib.util.spec_from_file_location("bulkonly_build_conditions", K1 / "tools" / "build_conditions.py")
+    BC = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(BC)
+    bsrc = K1 / "data" / ds / "bulkonly_raw.npz"
+    build1 = json.loads((K1 / "data" / ds / "BUILD.json").read_text())
+    if sha(bsrc) != build1["files"]["bulkonly_raw.npz"]:
+        raise SystemExit(f"{bsrc} differs from its BUILD.json sha")
+    b = np.load(bsrc, allow_pickle=True)
+    man = json.loads((ddir / "MANIFEST.json").read_text())
+    h5 = Path(man["inputs"]["bulk_harmonized"]["path"])
+    if sha(h5) != man["inputs"]["bulk_harmonized"]["sha256"] or str(h5) != build1["bulk_harmonized"]["path"]:
+        raise SystemExit(f"{h5}: differs from MANIFEST.json / the first plan's BUILD.json")
+    order = b["sample_ids"].astype(str).tolist()
+    Xb, Vb = BC.read_bulk(h5, order, d["gene_ids"])
+    b1 = counts_at(Xb, Vb, 1000)
+    checks["bulkonly_K1000_equals_bulkonly_raw"] = bool(
+        np.array_equal(b1, b["bulk_counts"]) and np.array_equal(b1, RB.to_condition_counts(Xb, Vb))
+        and (b["recipe_k"] == 1000).all() and np.array_equal(Vb.astype(np.float32), b["bulk_measurement_fraction"]))
+    bad = [key for key, v in checks.items() if v is not True]
+    if bad:
+        raise SystemExit(f"checks failed: {bad}")
+
+    files["training"] = derive(ddir / "conditions_raw_fixed.npz", out / f"conditions_raw_fixed_K{k}.npz", ck, k, None)
+    files["paired"] = {}
+    for j, (src, rows) in paired.items():
+        files["paired"][j] = derive(src, out / "paired_test" / f"draw{j}_test_raw_K{k}.npz", ck[rows], k, 1500)
+    files["bulkonly"] = derive(bsrc, out / f"bulkonly_raw_K{k}.npz", counts_at(Xb, Vb, k), k, a.cells_bulkonly)
+    meta_src = K1 / "data" / ds / "bulkonly_meta.csv"
+    if sha(meta_src) != build1["files"]["bulkonly_meta.csv"]:
+        raise SystemExit(f"{meta_src} differs from its BUILD.json sha")
+    shutil.copy2(meta_src, out / "bulkonly_meta.csv")
+    files["bulkonly_meta.csv"] = {"file": str(out / "bulkonly_meta.csv"), "sha256": sha(out / "bulkonly_meta.csv"),
+                                  "source": str(meta_src)}
+    rec = {"dataset": ds, "k": k, "cells_per_bulk": {"training": "unchanged (not used by ft_sdd.py)", "paired": 1500,
+                                                     "bulkonly": a.cells_bulkonly},
+           "written_utc": datetime.now(timezone.utc).isoformat(), "tool": str(Path(__file__).resolve()),
+           "tool_sha256": sha(Path(__file__)), "builder": str(PD.BUILDER), "builder_sha256": sha(Path(PD.BUILDER)),
+           "prepare_dataset_sha256": sha(FT / "tools/prepare_dataset.py"),
+           "first_plan_build_conditions_sha256": sha(K1 / "tools" / "build_conditions.py"),
+           "depth_anchor": float(RB.DEPTH_ANCHOR), "checks": checks, "files": files}
+    (out / "K_BUILD.json").write_text(json.dumps(rec, indent=1, default=str) + "\n")
+    print(json.dumps({"dataset": ds, "k": k, "checks": checks,
+                      "rows": {"training": files["training"]["rows"], "bulkonly": files["bulkonly"]["rows"],
+                               "paired": {j: v["rows"] for j, v in files["paired"].items()}}}, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())