Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20260928T225702Z-paired-ft-scsemi-delta/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tests/test_adapter.py

@@ -0,0 +1,53 @@
+"""CPU contract tests for the scSemiProfiler -> benchmark NPZ adapter rules (run with CUDA_VISIBLE_DEVICES='')."""
+import importlib.util
+import os
+from pathlib import Path
+import unittest
+
+import numpy as np
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+spec = importlib.util.spec_from_file_location("export_npz", Path(__file__).resolve().parents[1] / "tools/export_npz.py")
+E = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(E)
+
+
+class PickRows(unittest.TestCase):
+    def test_without_replacement_when_enough(self):
+        r = E.pick_rows(4000, "S1")
+        self.assertEqual(r.size, 1500)
+        self.assertEqual(np.unique(r).size, 1500)
+        self.assertTrue(np.all(np.diff(r) >= 0) and r.max() < 4000)
+
+    def test_exact_1500(self):
+        self.assertTrue(np.array_equal(E.pick_rows(1500, "S1"), np.arange(1500)))
+
+    def test_balanced_reuse_when_short(self):
+        for n in (1, 7, 400, 1499):
+            m = np.bincount(E.pick_rows(n, "S2"), minlength=n)
+            self.assertEqual(m.sum(), 1500)
+            self.assertGreaterEqual(m.min(), 1500 // n)
+            self.assertLessEqual(m.max(), -(-1500 // n))
+
+    def test_deterministic_and_target_keyed(self):
+        self.assertTrue(np.array_equal(E.pick_rows(5000, "A"), E.pick_rows(5000, "A")))
+        self.assertFalse(np.array_equal(E.pick_rows(5000, "A"), E.pick_rows(5000, "B")))
+
+    def test_empty_rejected(self):
+        with self.assertRaises(ValueError):
+            E.pick_rows(0, "S")
+
+
+class Depth(unittest.TestCase):
+    def test_rescale_and_zero_rows(self):
+        X = np.array([[0.0, 0.0, 0.0], [10.0, 30.0, 0.0], [5000.0, 2500.0, 2500.0]])
+        Y, nz = E.to_expected_counts(X, 1200.0)
+        self.assertEqual(nz, 1)
+        self.assertTrue(np.all(Y[0] == 0))
+        np.testing.assert_allclose(Y[1:].sum(1), 1200.0, rtol=1e-6)
+        np.testing.assert_allclose(Y[1], [300.0, 900.0, 0.0], rtol=1e-6)
+        self.assertEqual(Y.dtype, np.float32)
+
+
+if __name__ == "__main__":
+    unittest.main()

paper-releases/pbisc-diffusion/updates/20260928T225702Z-paired-ft-scsemi-delta/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/build_geneset_assets.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+"""Translate the pinned c2.cp GMT to the final 6k panel's Ensembl IDs (CPU only, run once).
+
+Same mapping policy and the same translate_gmt() as the frozen ImMicro campaign
+(immicro_scsemi_comparison_20260927/tools/prepare_geneset_assets.py, imported read-only):
+uppercase panel symbols, each pathway symbol -> ALL matching panel Ensembl IDs, de-duplicated within a
+pathway, pathway order and every empty pathway kept. The frozen campaign translated against its 5,913-gene
+axis; here the axis is the whole 6,000-gene panel so that one asset serves every dataset's modeled axis
+(upstream getGeneSetMatrix intersects each pathway with the modeled genes, so genes outside a dataset's axis
+are ignored exactly as if the GMT had been translated against that axis).
+
+Fail-closed check: restricted to the frozen 5,913 axis, every translated pathway equals the frozen mapped
+GMT's pathway (same genes, same order).
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+
+import pandas as pd
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+FROZEN = M8 / "plans/immicro_scsemi_comparison_20260927"
+HERE = Path(__file__).resolve().parents[1]
+PANEL = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/selected_genes.csv"
+VENDOR = HERE / "vendor/scSemiProfiler"
+
+
+def sha(path: Path) -> str:
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def main() -> None:
+    spec = importlib.util.spec_from_file_location("frozen_prepare_geneset_assets", FROZEN / "tools/prepare_geneset_assets.py")
+    frozen = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(frozen)
+    original = VENDOR / "genesets/c2.cp.v7.4.symbols.gmt"
+    if sha(original) != frozen.GMT_SHA256:
+        raise SystemExit("pinned GMT differs from the frozen campaign's")
+    panel = pd.read_csv(PANEL)
+    if len(panel) != 6000 or panel.gene_id.duplicated().any():
+        raise SystemExit("expected the 6,000-gene panel")
+    mapping: dict[str, list[str]] = {}
+    for gid, sym in zip(panel.gene_id.astype(str), panel.gene_symbol.astype(str)):
+        s = sym.strip().upper()
+        if not s or s == "NAN":
+            raise SystemExit(f"missing symbol for {gid}")
+        mapping.setdefault(s, []).append(gid)
+    text, report = frozen.translate_gmt(original, mapping)
+    if report["pathways"] != 2922:
+        raise SystemExit("unexpected pathway count")
+    # fail-closed equivalence with the frozen asset on the frozen axis
+    fz_assets = json.loads((FROZEN / "outputs/scsemi_genesets/geneset_assets.json").read_text())
+    fz_gmt = FROZEN / "outputs/scsemi_genesets/genesets/c2.cp.v7.4.symbols.gmt"
+    if sha(fz_gmt) != fz_assets["mapped_gmt_sha256"]:
+        raise SystemExit("frozen mapped GMT hash mismatch")
+    axis = set(fz_assets["gene_ids"])
+    mine = [ln.split("\t") for ln in text.splitlines()]
+    theirs = [ln.split("\t") for ln in fz_gmt.read_text().splitlines()]
+    if len(mine) != len(theirs):
+        raise SystemExit("pathway count differs from the frozen GMT")
+    for a, b in zip(mine, theirs):
+        if a[:2] != b[:2] or [g for g in a[2:] if g in axis] != b[2:]:
+            raise SystemExit(f"pathway {a[0]} differs from the frozen translation on the frozen axis")
+    out = HERE / "genesets"
+    out.mkdir(exist_ok=True)
+    dest = out / "c2.cp.v7.4.symbols.gmt"
+    record = {
+        "schema": "scsemi_paired.geneset_assets.v1",
+        "source_commit": "c2aea021188759e56ecf14578915c0237aaa75d2",
+        "original_gmt_sha256": frozen.GMT_SHA256,
+        "panel_csv": str(PANEL), "panel_csv_sha256": sha(PANEL),
+        "mapped_gmt_sha256": hashlib.sha256(text.encode()).hexdigest(),
+        "mapping_policy": "frozen campaign translate_gmt(): uppercase panel symbols; each pathway symbol -> ALL matching "
+                          "panel Ensembl IDs; de-duplicated within pathway; pathway order and empty pathways kept.",
+        "translated_against": "final 6,000-gene panel (upstream intersects each pathway with the dataset's modeled axis)",
+        "pathways": report["pathways"], "empty_pathways_on_panel": len(report["empty_pathway_ids"]),
+        "covered_panel_genes": len(report["covered_gene_ids"]),
+        "symbol_collisions": {s: g for s, g in mapping.items() if len(g) > 1},
+        "frozen_equivalence_check": {"frozen_mapped_gmt_sha256": fz_assets["mapped_gmt_sha256"],
+                                     "frozen_axis_genes": len(axis),
+                                     "every_pathway_equal_on_frozen_axis": True},
+        "builder_sha256": sha(Path(__file__)),
+    }
+    if dest.exists() or (out / "geneset_assets.json").exists():
+        old = json.loads((out / "geneset_assets.json").read_text())
+        if old["mapped_gmt_sha256"] != record["mapped_gmt_sha256"] or sha(dest) != record["mapped_gmt_sha256"]:
+            raise SystemExit("existing assets differ; preserve and inspect")
+        print("existing assets verified")
+        return
+    dest.write_text(text)
+    (out / "geneset_assets.json").write_text(json.dumps(record, indent=2) + "\n")
+    print(json.dumps({k: record[k] for k in ("mapped_gmt_sha256", "pathways", "empty_pathways_on_panel",
+                                             "covered_panel_genes")}))
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20260928T225702Z-paired-ft-scsemi-delta/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/compare_prepared.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""Compare two upstream-prepared split directories file by file (sha256 from each prepared.json, plus the inputs).
+
+Used to show that the lean cell graph reproduces upstream's prepared project bit for bit on full production draws
+(the two runs differ only in the wrapper version / cell-graph implementation).
+usage: compare_prepared.py OUT.json OLD_WORK:NEW_WORK [OLD_WORK:NEW_WORK ...]
+"""
+import json
+import sys
+from pathlib import Path
+
+out, pairs = Path(sys.argv[1]), sys.argv[2:]
+res, ok = {}, True
+for pair in pairs:
+    old, new = (Path(x) for x in pair.split(":"))
+    po, pn = (json.loads((w / "prepared.json").read_text()) for w in (old, new))
+    io, inn = (json.loads((w / "inputs/inputs_manifest.json").read_text())["files"] for w in (old, new))
+    diff = sorted(k for k in set(po["files"]) | set(pn["files"]) if po["files"].get(k) != pn["files"].get(k))
+    same_inputs = io == inn
+    res[str(new)] = {"old": str(old), "n_files": len(pn["files"]), "different": diff, "inputs_identical": same_inputs,
+                     "sample_sc_files": sum(k.startswith("sample_sc/") for k in pn["files"]),
+                     "identical": not diff and same_inputs}
+    ok &= res[str(new)]["identical"]
+    print(new.name, res[str(new)]["identical"], len(pn["files"]), diff[:3])
+out.write_text(json.dumps({"all_identical": ok, "splits": res}, indent=1) + "\n")
+sys.exit(0 if ok else 1)

paper-releases/pbisc-diffusion/updates/20260928T225702Z-paired-ft-scsemi-delta/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/compare_runs.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+"""Bitwise comparison of two scSemiProfiler work dirs' trained artefacts (CPU only; CUDA must be hidden).
+
+Compares every pretrain checkpoint (fast_reconst1_*, fastreconst2_*), every per-target model (semi_*_to_*) as
+state-dict tensors (torch.equal, same dtype/shape/keys) and every target shard (CSR arrays equal).
+usage: compare_runs.py OUT.json WORK_A WORK_B
+"""
+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 scipy.sparse as sp
+import torch
+
+
+def same_state(pa: Path, pb: Path) -> bool:
+    a = torch.load(pa, map_location="cpu", weights_only=True)
+    b = torch.load(pb, map_location="cpu", weights_only=True)
+    return a.keys() == b.keys() and all(a[k].dtype == b[k].dtype and a[k].shape == b[k].shape and torch.equal(a[k], b[k]) for k in a)
+
+
+def main() -> int:
+    out, wa, wb = Path(sys.argv[1]), Path(sys.argv[2]), Path(sys.argv[3])
+    res = {}
+    for m in sorted((wa / "scsemi_project/models").iterdir()):
+        if m.name.endswith(".receipt.json"):
+            continue
+        other = wb / "scsemi_project/models" / m.name
+        res[f"models/{m.name}"] = other.exists() and same_state(m, other)
+    for s in sorted((wa / "shards").glob("*.npz")):
+        other = wb / "shards" / s.name
+        if not other.exists():
+            res[f"shards/{s.name}"] = False
+            continue
+        A, B = sp.load_npz(s), sp.load_npz(other)
+        res[f"shards/{s.name}"] = bool(A.shape == B.shape and A.dtype == B.dtype and (A != B).nnz == 0)
+    ok = bool(res) and all(res.values())
+    out.write_text(json.dumps({"a": str(wa), "b": str(wb), "all_identical": ok, "items": res}, indent=1) + "\n")
+    print(json.dumps({"all_identical": ok, "n_items": len(res), "different": [k for k, v in res.items() if not v]}))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())