Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/28/ISOLATION.json

@@ -0,0 +1,70 @@
+{
+  "schema": "pbisc.paper.support-expression-isolation.v1",
+  "support_manifest": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/protocol/splits/immicro/healthy/fold0/n5/support.json",
+  "support_sha256": "85c04462a9c768c205fc0adfcb0a40e5f94f504a93d6d822944387bc055b65d4",
+  "cohort": "immicro",
+  "unit": "fold0_n5",
+  "train_sample_ids": [
+    "HS40",
+    "HS30",
+    "HS53",
+    "HS39",
+    "HS109"
+  ],
+  "train_donor_ids": [
+    "HS40",
+    "HS30",
+    "HS53",
+    "HS39",
+    "HS109"
+  ],
+  "source_cells": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/cells_panel6k.npz",
+  "source_cells_sha256": "e1168468b621183604038b79280f46961c5819fe2386d9da0b454f7db642742a",
+  "source_folds_sha256": "0adc10f4ac973e5b7558effbea0fd6950a6bf59e5af1d3a376e12eb00bf6a643",
+  "isolated_cells": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold0/n5/cells_support_only.npz",
+  "isolated_cells_sha256": "210852d2bc7d96c41973d1e054d8022061775566d8ca6b2c3abfb3c612a42760",
+  "builder_sha256": "762f5f7bbf908c478544b0c5c05a8fbf6c3bf63eff6a2d7af88105473c1c20a2",
+  "audit": {
+    "selected_sample_rows": [
+      27,
+      35,
+      36,
+      49,
+      104
+    ],
+    "selected_cells": 18179,
+    "selected_nonzero_entries": 7032111,
+    "original_cell_rows": 392251,
+    "nonselected_expression_rows_empty": true,
+    "original_expression_ranges": [
+      [
+        39381299,
+        41950421
+      ],
+      [
+        51123627,
+        53172512
+      ],
+      [
+        70214002,
+        70836609
+      ],
+      [
+        144456310,
+        146247807
+      ]
+    ],
+    "cell_row_indexing": "unchanged original cell-row indices; non-support rows have empty CSR rows",
+    "data_sha256": "68f455a04934edc4c64777ae5de4be989ac02b7ea631acfd6a082c6bde090e0d",
+    "indices_sha256": "cddf7c6ec873dc5274c0eac1679d4e4ce0d46142f01fd699f2537bdacce4d1e4"
+  },
+  "expression_access": "Only selected CSR ranges interpreted. Nonselected compressed bytes may be streamed and discarded.",
+  "target_sc_aggregate_keys_accessed": [],
+  "permitted_all_row_metadata": [
+    "indptr",
+    "row_sample",
+    "shape",
+    "panel_gene_ids",
+    "panel_measured"
+  ]
+}

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/29/ISOLATION.json

@@ -0,0 +1,74 @@
+{
+  "schema": "pbisc.paper.support-expression-isolation.v1",
+  "support_manifest": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/protocol/splits/immicro/healthy/fold1/n5/support.json",
+  "support_sha256": "84d7e7a40992a7f24ceb5017c7534e2897d89246de9747c0a683442ad506e155",
+  "cohort": "immicro",
+  "unit": "fold1_n5",
+  "train_sample_ids": [
+    "HS25",
+    "HS95",
+    "HS77",
+    "HS14",
+    "HS108"
+  ],
+  "train_donor_ids": [
+    "HS25",
+    "HS95",
+    "HS77",
+    "HS14",
+    "HS108"
+  ],
+  "source_cells": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/cells_panel6k.npz",
+  "source_cells_sha256": "e1168468b621183604038b79280f46961c5819fe2386d9da0b454f7db642742a",
+  "source_folds_sha256": "0adc10f4ac973e5b7558effbea0fd6950a6bf59e5af1d3a376e12eb00bf6a643",
+  "isolated_cells": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold1/n5/cells_support_only.npz",
+  "isolated_cells_sha256": "2c9f63bb7c207d9e74f6bb400e6a33284310ae4becabd5f5d1744622d7edb2bd",
+  "builder_sha256": "762f5f7bbf908c478544b0c5c05a8fbf6c3bf63eff6a2d7af88105473c1c20a2",
+  "audit": {
+    "selected_sample_rows": [
+      12,
+      22,
+      73,
+      91,
+      103
+    ],
+    "selected_cells": 15829,
+    "selected_nonzero_entries": 5827615,
+    "original_cell_rows": 392251,
+    "nonselected_expression_rows_empty": true,
+    "original_expression_ranges": [
+      [
+        19315918,
+        20936925
+      ],
+      [
+        32541625,
+        33326602
+      ],
+      [
+        102941774,
+        104113707
+      ],
+      [
+        125793775,
+        127286443
+      ],
+      [
+        143699280,
+        144456310
+      ]
+    ],
+    "cell_row_indexing": "unchanged original cell-row indices; non-support rows have empty CSR rows",
+    "data_sha256": "dc4b7969ff82490fc659fd1ece85cfd77bb08a35e165aaf47bfa7132802d7174",
+    "indices_sha256": "ae0414a973516ad0ed080b8ed626d680fa29211263d7ec1d13377f9fdf2d82c9"
+  },
+  "expression_access": "Only selected CSR ranges interpreted. Nonselected compressed bytes may be streamed and discarded.",
+  "target_sc_aggregate_keys_accessed": [],
+  "permitted_all_row_metadata": [
+    "indptr",
+    "row_sample",
+    "shape",
+    "panel_gene_ids",
+    "panel_measured"
+  ]
+}

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/30/support_input_isolation.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Materialize expression only for exact support samples; keep original row indices.
+
+Unselected cell rows contain no expression entries. Their sample/row-count
+metadata remains so random cell selection in the legacy trainer is unchanged.
+ZIP bytes before selected ranges may be decompressed and discarded, but are
+never interpreted or materialized as expression arrays.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import zipfile
+
+import numpy as np
+import pandas as pd
+
+from support_manifest import load_manifest, select_rows
+
+PLAN = Path(__file__).resolve().parents[1]
+OLD = PLAN.parents[1] / "plans/paired_finetune_intradataset_20260927"
+SCHEMA = "pbisc.paper.support-expression-isolation.v1"
+CHUNK = 8 * 1024 * 1024
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        for block in iter(lambda: stream.read(CHUNK), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def _discard(stream, size: int) -> None:
+    while size:
+        got = stream.read(min(size, CHUNK))
+        if not got:
+            raise ValueError("truncated NPZ member")
+        size -= len(got)
+
+
+def read_ranges(path: Path, member: str, ranges: list[tuple[int, int]]) -> np.ndarray:
+    """Read only selected slices of a one-dimensional numeric NPZ member."""
+    with zipfile.ZipFile(path) as archive, archive.open(member + ".npy") as stream:
+        version = np.lib.format.read_magic(stream)
+        if version == (1, 0):
+            shape, order, dtype = np.lib.format.read_array_header_1_0(stream)
+        elif version == (2, 0):
+            shape, order, dtype = np.lib.format.read_array_header_2_0(stream)
+        else:
+            raise ValueError(f"unsupported npy version {version}")
+        if len(shape) != 1 or dtype.hasobject:
+            raise ValueError("only numeric one-dimensional members are permitted")
+        previous = 0
+        for lo, hi in ranges:
+            if not previous <= lo <= hi <= shape[0]:
+                raise ValueError("invalid or overlapping selected ranges")
+            previous = hi
+        out = np.empty(sum(hi - lo for lo, hi in ranges), dtype=dtype)
+        position, offset = 0, 0
+        view = memoryview(out).cast("B")
+        for lo, hi in ranges:
+            _discard(stream, (lo - position) * dtype.itemsize)
+            remaining = (hi - lo) * dtype.itemsize
+            while remaining:
+                got = stream.read(min(remaining, CHUNK))
+                if not got:
+                    raise ValueError("truncated selected expression range")
+                view[offset:offset + len(got)] = got
+                offset += len(got)
+                remaining -= len(got)
+            position = hi
+        return out
+
+
+def isolated_arrays(source: Path, selected_rows: np.ndarray) -> tuple[dict, dict]:
+    # Every key accessed here is structural metadata; expression is streamed below.
+    with np.load(source, allow_pickle=False) as z:
+        ip = z["indptr"].astype(np.int64)
+        rs = z["row_sample"].astype(np.int64)
+        shape = z["shape"].astype(np.int64)
+        panel = z["panel_gene_ids"]
+        measured = z["panel_measured"]
+    if len(ip) != len(rs) + 1 or int(shape[0]) != len(rs) or np.any(np.diff(rs) < 0):
+        raise ValueError("invalid or unsorted cell-row metadata")
+    if ip[0] != 0 or np.any(np.diff(ip) < 0):
+        raise ValueError("invalid CSR indptr")
+    selected_rows = np.unique(selected_rows).astype(np.int64)
+    if not set(selected_rows.tolist()) <= set(rs.tolist()):
+        raise ValueError("support sample has no retained cells")
+    use = np.isin(rs, selected_rows)
+    chosen = np.flatnonzero(use)
+    starts = chosen[np.r_[True, np.diff(chosen) != 1]]
+    ends = chosen[np.r_[np.diff(chosen) != 1, True]] + 1
+    ranges = [(int(ip[a]), int(ip[b])) for a, b in zip(starts, ends)]
+    data = read_ranges(source, "data", ranges)
+    indices = read_ranges(source, "indices", ranges)
+    lengths = np.where(use, np.diff(ip), 0)
+    new_ip = np.r_[0, np.cumsum(lengths, dtype=np.int64)]
+    if len(data) != len(indices) or len(data) != int(new_ip[-1]):
+        raise ValueError("selected CSR member sizes disagree")
+    arrays = dict(data=data, indices=indices, indptr=new_ip, row_sample=rs,
+                  shape=shape, panel_gene_ids=panel, panel_measured=measured)
+    audit = {"selected_sample_rows": selected_rows.tolist(),
+             "selected_cells": int(use.sum()), "selected_nonzero_entries": int(len(data)),
+             "original_cell_rows": int(len(rs)), "nonselected_expression_rows_empty": True,
+             "original_expression_ranges": ranges,
+             "cell_row_indexing": "unchanged original cell-row indices; non-support rows have empty CSR rows",
+             "data_sha256": hashlib.sha256(data.tobytes()).hexdigest(),
+             "indices_sha256": hashlib.sha256(indices.tobytes()).hexdigest()}
+    return arrays, audit
+
+
+def resolve_support(support_path: Path) -> tuple[dict, Path, Path, np.ndarray]:
+    support_path = support_path.resolve()
+    relative = support_path.parent.relative_to(PLAN / "protocol/splits")
+    initial = json.loads(support_path.read_text())
+    dataset = OLD / "data" / initial["cohort"]
+    folds = pd.read_csv(dataset / "folds.csv", dtype={"sample_id": str, "donor_id": str})
+    support = load_manifest(support_path, folds)
+    rows, _ = select_rows(support, folds)
+    return support, dataset, PLAN / "isolated" / relative, rows
+
+
+def materialize(support_path: Path) -> tuple[Path, dict]:
+    support, dataset, out, rows = resolve_support(support_path)
+    source = dataset / "cells_panel6k.npz"
+    receipt_path = out / "ISOLATION.json"
+    cell_path = out / "cells_support_only.npz"
+    if receipt_path.exists():
+        receipt = json.loads(receipt_path.read_text())
+        if (receipt.get("schema") != SCHEMA or receipt["support_sha256"] != support["sha256"]
+                or receipt["source_cells_sha256"] != sha(source)
+                or receipt["source_folds_sha256"] != sha(dataset / "folds.csv")
+                or receipt["isolated_cells_sha256"] != sha(cell_path)):
+            raise ValueError("immutable isolation receipt/input mismatch")
+        return cell_path, receipt
+    if cell_path.exists():
+        raise ValueError("unreceipted isolated cell file exists; inspect without overwriting")
+    out.mkdir(parents=True, exist_ok=True)
+    arrays, audit = isolated_arrays(source, rows)
+    temporary = out / "cells_support_only.npz.tmp"
+    if temporary.exists():
+        raise ValueError("partial isolation output exists; inspect before retry")
+    with temporary.open("xb") as stream:
+        np.savez_compressed(stream, **arrays)
+    os.replace(temporary, cell_path)
+    receipt = {"schema": SCHEMA, "support_manifest": str(support_path.resolve()),
+               "support_sha256": support["sha256"], "cohort": support["cohort"],
+               "unit": support["unit"], "train_sample_ids": support["train_sample_ids"],
+               "train_donor_ids": support["train_donor_ids"], "source_cells": str(source),
+               "source_cells_sha256": sha(source), "source_folds_sha256": sha(dataset / "folds.csv"),
+               "isolated_cells": str(cell_path), "isolated_cells_sha256": sha(cell_path),
+               "builder_sha256": sha(Path(__file__)), "audit": audit,
+               "expression_access": "Only selected CSR ranges interpreted. Nonselected compressed bytes may be streamed and discarded.",
+               "target_sc_aggregate_keys_accessed": [], "permitted_all_row_metadata":
+               ["indptr", "row_sample", "shape", "panel_gene_ids", "panel_measured"]}
+    receipt_path.write_text(json.dumps(receipt, indent=2) + "\n")
+    return cell_path, receipt
+
+
+def validate_replay(support_path: Path, seed: int = 20260927) -> dict:
+    """Compare every selected CSR value and replay cell draws without training."""
+    path, receipt = materialize(support_path)
+    support, dataset, out, rows = resolve_support(support_path)
+    expected, audit = isolated_arrays(dataset / "cells_panel6k.npz", rows)
+    with np.load(path, allow_pickle=False) as got:
+        for key, value in expected.items():
+            if not np.array_equal(got[key], value):
+                raise ValueError(f"isolation replay differs: {key}")
+        rs = got["row_sample"]
+        ip = got["indptr"]
+        if np.any(np.diff(ip)[~np.isin(rs, rows)] != 0):
+            raise ValueError("non-support expression was retained")
+    with np.load(dataset / "cells_panel6k.npz", allow_pickle=False) as original:
+        orig_rs = original["row_sample"]
+    n = max(int(orig_rs.max()), int(rs.max())) + 1
+    old_start = np.searchsorted(orig_rs, np.arange(n), "left")
+    start = np.searchsorted(rs, np.arange(n), "left")
+    old_count = np.searchsorted(orig_rs, np.arange(n), "right") - old_start
+    count = np.searchsorted(rs, np.arange(n), "right") - start
+    rng_a, rng_b = np.random.default_rng(seed), np.random.default_rng(seed)
+    canonical_rows = np.sort(rows)
+    for _ in range(3000):
+        ra = canonical_rows[rng_a.integers(0, len(rows), 256)]
+        rb = canonical_rows[rng_b.integers(0, len(rows), 256)]
+        ca = old_start[ra] + np.floor(rng_a.random(256) * old_count[ra]).astype(np.int64)
+        cb = start[rb] + np.floor(rng_b.random(256) * count[rb]).astype(np.int64)
+        if not np.array_equal(ra, rb) or not np.array_equal(ca, cb):
+            raise ValueError("training draw replay changed")
+    result = {"schema": "pbisc.paper.support-isolation-replay.v1", "support_sha256": support["sha256"],
+              "isolated_cells_sha256": receipt["isolated_cells_sha256"], "all_selected_values_exact": True,
+              "training_draws_exact": True, "updates": 3000, "batch_size": 256, "seed": seed,
+              "legacy_access_limitation": "Earlier loaders materialized non-support arrays before selection; replay verifies selected computation only and does not change historical access claims."}
+    (out / "REPLAY.json").write_text(json.dumps(result, indent=2) + "\n")
+    return result
+
+
+def bulk_only_load(dataset: Path) -> dict:
+    """prepare_dataset.load equivalent for bulk and metadata, without sc sums."""
+    with np.load(dataset / "features.npz", allow_pickle=False) as f:
+        samples = pd.read_csv(dataset / "samples.csv")
+        ids = (f["sample_ids"] if "sample_ids" in f.files else f["donor_ids"]).astype(str)
+        if not np.array_equal(ids, samples.sample_id.astype(str).to_numpy()):
+            raise ValueError("sample order differs between metadata and features")
+        bv, sv = f["bulk_valid"].astype(bool), f["sc_valid"].astype(bool)
+        raw = f["bulk_raw"]
+        if np.any(~np.isfinite(raw[bv])) or np.any(raw[bv] < 0):
+            raise ValueError("invalid measured bulk counts")
+        bulk = np.where(bv, raw, 0)
+        result = {"gene_ids": f["gene_ids"].astype(str), "sample_ids": ids,
+                  "donor_ids": samples.donor_id.astype(str).to_numpy(),
+                  "groups": samples.group.astype(str).to_numpy(),
+                  "bulk_valid": bv, "sc_valid": sv, "bulk": bulk,
+                  "n_cells": samples.n_cells.to_numpy(np.int64)}
+        # This field is not used to choose support; canonical folds do that.
+        result["use"] = f["identity_pass"].astype(bool) if "identity_pass" in f.files else np.ones(len(ids), bool)
+    return result
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--support-manifest", type=Path, required=True)
+    ap.add_argument("--validate-replay", action="store_true")
+    ap.add_argument("--seed", type=int, default=20260927)
+    a = ap.parse_args(argv)
+    if a.validate_replay:
+        result = validate_replay(a.support_manifest, a.seed)
+    else:
+        path, receipt = materialize(a.support_manifest)
+        result = {"path": str(path), "sha256": receipt["isolated_cells_sha256"], "audit": receipt["audit"]}
+    print(json.dumps(result))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/31/ft_sdd.py

@@ -0,0 +1,496 @@
+#!/usr/bin/env python3
+"""Fine-tune the final PBISC-SDD model inside one paired dataset fold.
+
+Training pairs are (condition of row r, one retained cell of row r).  The condition comes from a condition NPZ
+written by prepare_dataset.py (real bulk or pseudobulk, fixed-depth policy) and goes through the checkpoint's own
+conditioner exactly as the standalone sampler does (sample_sdd_standalone.load_conditions), then
+condition_with_measurement_context(base, bulk_measurement_fraction, output_availability_mask).  The loss is the
+pretraining loss (SparseDataDiffusion.training_loss: measured-only value L2 + support BCE, self-conditioning),
+with bf16 autocast, AdamW and gradient clipping as in pretraining.
+
+Rows: fold k's test rows are never loaded.  Training rows = the other folds minus the inner-validation rows;
+inner-validation rows give a fixed-draw diffusion loss every --eval-every steps, and the EMA state with the lowest
+inner-validation loss is kept (early stopping with --patience evaluations).
+
+Modes (what is trainable):
+  full     every denoiser parameter
+  condenc  only denoiser.condition_encoder (the bulk -> context map)
+  lora     low-rank updates W = W0 + (alpha/r) B A on every nn.Linear of the denoiser (B starts at zero);
+           merged into the weights before saving
+
+Batches are donor-balanced: a row is drawn uniformly, then one of its cells uniformly.
+
+The output checkpoint keeps the input checkpoint's schema and self-contained keys, with model_state and
+ema_state.model_state set to the selected weights, so scripts/sample_sdd_standalone.py samples it unchanged.
+src/pbisc_sdd is sealed and is only imported.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from torch import nn
+import torch.nn.utils.parametrize as parametrize
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+for p in (M8 / "src", M8 / "scripts"):
+    if str(p) not in sys.path:
+        sys.path.insert(0, str(p))
+import sample_sdd_standalone as SS  # noqa: E402
+from pbisc_sdd.data import condition_with_measurement_context  # noqa: E402
+
+SCHEMA = "pbisc_sdd.ft_intradataset.run.v1"
+KEEP_KEYS = ("schema_version", "model_config", "diffusion_config", "value_scaler", "conditioner_state",
+             "gene_positions", "gene_ids", "gene_symbols", "gene_measurement_coverage",
+             "full_gene_measurement_coverage", "corpus_fingerprint", "experiment_config", "proportion_hint",
+             "training_contract")
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def log(msg: str) -> None:
+    print(f"{datetime.now().isoformat(timespec='seconds')} {msg}", flush=True)
+
+
+# ----------------------------------------------------------------------------------------------- LoRA
+class LoRADelta(nn.Module):
+    """Parametrization W -> W + scale * B @ A (B zero-initialised, so the start equals the pretrained W)."""
+
+    def __init__(self, out_features: int, in_features: int, rank: int, alpha: float) -> None:
+        super().__init__()
+        self.A = nn.Parameter(torch.empty(rank, in_features))
+        self.B = nn.Parameter(torch.zeros(out_features, rank))
+        nn.init.kaiming_uniform_(self.A, a=math.sqrt(5))
+        self.scale = float(alpha) / float(rank)
+
+    def forward(self, weight: torch.Tensor) -> torch.Tensor:
+        return weight + self.scale * (self.B @ self.A).to(dtype=weight.dtype)
+
+
+def add_lora(model: nn.Module, rank: int, alpha: float) -> list[str]:
+    names = []
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear):
+            delta = LoRADelta(module.out_features, module.in_features, rank, alpha).to(
+                device=module.weight.device, dtype=module.weight.dtype)
+            parametrize.register_parametrization(module, "weight", delta)
+            names.append(name)
+    return names
+
+
+def merge_lora(model: nn.Module) -> None:
+    for module in model.modules():
+        if isinstance(module, nn.Linear) and parametrize.is_parametrized(module, "weight"):
+            parametrize.remove_parametrizations(module, "weight", leave_parametrized=True)
+
+
+def set_trainable(denoiser: nn.Module, mode: str, rank: int, alpha: float) -> dict:
+    for p in denoiser.parameters():
+        p.requires_grad_(False)
+    info: dict = {"mode": mode}
+    if mode == "full":
+        for p in denoiser.parameters():
+            p.requires_grad_(True)
+    elif mode == "condenc":
+        for p in denoiser.condition_encoder.parameters():
+            p.requires_grad_(True)
+    elif mode == "lora":
+        info["lora_layers"] = add_lora(denoiser, rank, alpha)
+        info["lora_rank"], info["lora_alpha"] = rank, alpha
+        for name, p in denoiser.named_parameters():
+            p.requires_grad_(name.endswith(".A") or name.endswith(".B"))
+    else:
+        raise SystemExit(f"unknown mode {mode}")
+    trainable = [n for n, p in denoiser.named_parameters() if p.requires_grad]
+    info["n_trainable"] = int(sum(p.numel() for p in denoiser.parameters() if p.requires_grad))
+    info["n_total_base"] = int(sum(p.numel() for n, p in denoiser.named_parameters()
+                                   if not (n.endswith(".A") or n.endswith(".B"))))
+    info["trainable_tensors"] = len(trainable)
+    return info
+
+
+# ----------------------------------------------------------------------------------------------- data
+class Cells:
+    """Retained cells on the 6k panel (CSR, rows sorted by dataset row)."""
+
+    def __init__(self, path: Path, panel_gene_ids: np.ndarray) -> None:
+        z = np.load(path, allow_pickle=False)
+        self.indptr = z["indptr"].astype(np.int64)
+        self.indices = z["indices"].astype(np.int64)
+        self.data = z["data"].astype(np.float32)
+        self.row_sample = z["row_sample"].astype(np.int64)
+        self.n_genes = int(z["shape"][1])
+        if not np.array_equal(z["panel_gene_ids"].astype(str), panel_gene_ids.astype(str)):
+            raise SystemExit("cells_panel6k columns differ from the checkpoint gene panel")
+        if bool((np.diff(self.row_sample) < 0).any()):
+            raise SystemExit("cells are not sorted by dataset row")
+        n_rows = int(self.row_sample.max()) + 1
+        self.start = np.searchsorted(self.row_sample, np.arange(n_rows), side="left")
+        self.count = np.searchsorted(self.row_sample, np.arange(n_rows), side="right") - self.start
+
+    def dense(self, cells: np.ndarray) -> np.ndarray:
+        s, e = self.indptr[cells], self.indptr[cells + 1]
+        lens = e - s
+        idx = np.concatenate([np.arange(a, b) for a, b in zip(s, e)]) if len(cells) else np.zeros(0, np.int64)
+        out = np.zeros((len(cells), self.n_genes), dtype=np.float32)
+        out[np.repeat(np.arange(len(cells)), lens), self.indices[idx]] = self.data[idx]
+        return out
+
+
+def draw_batch(cells: Cells, rows: np.ndarray, batch: int, rng: np.random.Generator) -> tuple[np.ndarray, np.ndarray]:
+    r = rows[rng.integers(0, len(rows), size=batch)]
+    c = cells.start[r] + np.floor(rng.random(batch) * cells.count[r]).astype(np.int64)
+    return r, c
+
+
+# ----------------------------------------------------------------------------------------------- main
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--checkpoint", type=Path, required=True)
+    ap.add_argument("--checkpoint-sha", required=True)
+    ap.add_argument("--dataset-dir", type=Path, required=True)
+    ap.add_argument("--condition-npz", type=Path, required=True, help="all-row condition NPZ used for training")
+    ap.add_argument("--fold", type=int, required=True)
+    ap.add_argument("--mode", choices=("full", "condenc", "lora"), required=True)
+    ap.add_argument("--lora-rank", type=int, default=16)
+    ap.add_argument("--lora-alpha", type=float, default=16.0)
+    ap.add_argument("--lr", type=float, required=True)
+    ap.add_argument("--warmup", type=int, default=200)
+    ap.add_argument("--batch-size", type=int, default=256)
+    ap.add_argument("--max-steps", type=int, default=20000)
+    ap.add_argument("--eval-every", type=int, default=250)
+    ap.add_argument("--patience", type=int, default=8)
+    ap.add_argument("--ema-decay", type=float, default=0.999)
+    ap.add_argument("--val-cells-per-row", type=int, default=256)
+    ap.add_argument("--val-repeats", type=int, default=2)
+    ap.add_argument("--seed", type=int, default=20260927)
+    ap.add_argument("--out-dir", type=Path, required=True)
+    ap.add_argument("--device", default="cuda")
+    ap.add_argument("--max-cuda-gib", type=float, default=8.0)
+    ap.add_argument("--min-system-gib", type=float, default=32.0)
+    ap.add_argument("--smoke", action="store_true", help="tiny run for tests (few steps, CPU allowed)")
+    ap.add_argument("--train-n", type=int, default=0, help="learning curve: number of training donors to keep")
+    ap.add_argument("--train-donors-file", default="", help="few-pair scenario: train on these donor_ids (one per "
+                    "line), no inner validation, every other usable row is test; --fold is ignored")
+    ap.add_argument("--fixed-steps", type=int, default=0, help="train exactly this many steps without inner "
+                    "validation and keep the final EMA state (for when no pairs can be spared for early stopping)")
+    ap.add_argument("--subset-seed", type=int, default=0)
+    ap.add_argument("--strata-regex", default="", help="groups matching this regex form one stratum, the rest another")
+    ap.add_argument("--support-manifest", type=Path, default=None,
+                    help="strict paired support.json: exact sample IDs, no inner validation; requires --fixed-steps 3000")
+    a = ap.parse_args(argv)
+
+    if a.support_manifest is not None:
+        if a.mode != "lora" or a.train_donors_file or a.train_n or a.fixed_steps != 3000 or a.smoke:
+            raise SystemExit("strict support requires LoRA, --fixed-steps 3000, no donor/subset override or smoke")
+        strict_tools = M8 / "plans/paper_figures_strictpairs_20261012/tools"
+        sys.path.insert(0, str(strict_tools))
+        from support_manifest import load_manifest, validate_existing_run
+        support_preflight = load_manifest(a.support_manifest, pd.read_csv(a.dataset_dir / "folds.csv",
+                                                                           dtype={"sample_id": str, "donor_id": str}))
+        if support_preflight["cohort"] != a.dataset_dir.name:
+            raise SystemExit("support cohort differs from dataset directory")
+    a.out_dir.mkdir(parents=True, exist_ok=True)
+    done = a.out_dir / "checkpoint_ft.pt"
+    if done.exists() and (a.out_dir / "RUN.json").exists():
+        if a.support_manifest is not None:
+            stored = json.loads((a.out_dir / "RUN.json").read_text())
+            validate_existing_run(support_preflight, stored, fixed_steps=a.fixed_steps,
+                                  lora_rank=a.lora_rank, source_checkpoint_sha256=a.checkpoint_sha,
+                                  condition_npz_sha256=sha256_file(a.condition_npz),
+                                  lr=a.lr, lora_alpha=a.lora_alpha, warmup=a.warmup,
+                                  batch_size=a.batch_size, ema_decay=a.ema_decay, seed=a.seed)
+            if sha256_file(a.checkpoint) != a.checkpoint_sha:
+                raise SystemExit("source checkpoint differs from requested hash")
+            if stored.get("checkpoint_sha256") != sha256_file(done):
+                raise SystemExit("existing strict checkpoint differs from RUN.json hash")
+        log(f"{done} exists; nothing to do")
+        return 0
+    if a.support_manifest is not None and (done.exists() or (a.out_dir / "RUN.json").exists()):
+        raise SystemExit("strict output is incomplete; inspect rather than overwrite")
+    avail = int(open("/proc/meminfo").read().split("MemAvailable:")[1].split()[0]) / 1048576
+    if avail < a.min_system_gib:
+        raise SystemExit(f"MemAvailable {avail:.1f} GiB < floor {a.min_system_gib}")
+    got = sha256_file(a.checkpoint)
+    if got != a.checkpoint_sha:
+        raise SystemExit(f"checkpoint sha {got[:12]} != {a.checkpoint_sha[:12]}")
+    device = torch.device(a.device)
+    if device.type == "cuda" and device.index is None:
+        device = torch.device("cuda", 0)
+    if device.type == "cuda":
+        total = torch.cuda.get_device_properties(device).total_memory
+        torch.cuda.set_per_process_memory_fraction(min(1.0, a.max_cuda_gib * 2**30 / total), device)
+    torch.manual_seed(a.seed)
+    rng = np.random.default_rng(a.seed)
+
+    bundle = SS.restore_standalone(a.checkpoint, device=device, weights="ema", conditioner_source="embedded")
+    diffusion, scaler = bundle.diffusion, bundle.scaler
+    ext = SS.load_conditions(a.condition_npz, bundle, default_cells_per_bulk=1)
+    folds = pd.read_csv(a.dataset_dir / "folds.csv")
+    if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), ext.sample_ids.astype(str)):
+        raise SystemExit("condition NPZ rows differ from folds.csv")
+    support = None
+    if a.support_manifest is not None:
+        from support_manifest import select_rows
+        support = support_preflight
+        train_rows, test_rows = select_rows(support, folds)
+        inner_rows = np.zeros(0, dtype=np.int64)
+        selected_visits = set(folds.loc[folds["donor_id"].astype(str).isin(support["train_donor_ids"]),
+                                        "sample_id"].astype(str))
+        if selected_visits - set(support["train_sample_ids"]) != set(support["excluded_sample_ids"]):
+            raise SystemExit("support excludes inconsistent selected-donor visits")
+        folds = folds.assign(fold=np.where(folds.index.isin(test_rows), 0,
+                                           np.where(folds.index.isin(train_rows), 1, -1)),
+                             inner_val_custom=False)
+        a.fold = 0
+        inner_col = "inner_val_custom"
+    elif a.train_donors_file:
+        # few-pair deployment scenario: train on the listed donors only, no inner validation, and treat every other
+        # usable row (fold >= 0) as test; --fold is ignored
+        want = {l.strip() for l in Path(a.train_donors_file).read_text().splitlines() if l.strip()}
+        is_train = folds["donor_id"].astype(str).isin(want) & (folds["fold"] >= 0)
+        if int(folds.loc[is_train, "donor_id"].nunique()) != len(want):
+            raise SystemExit("some listed training donors are missing or excluded")
+        folds = folds.assign(fold=np.where(folds["fold"] < 0, -1, np.where(is_train, 1, 0)))
+        folds["inner_val_custom"] = False
+        a.fold = 0
+        inner_col = "inner_val_custom"
+    else:
+        inner_col = f"inner_val_f{a.fold}"
+    test_rows = folds.index[folds["fold"] == a.fold].to_numpy()
+    inner_rows = folds.index[folds[inner_col]].to_numpy()
+    # fold -1 marks rows excluded by the pairing identity checks: never trained on, never tested
+    train_rows = folds.index[(folds["fold"] != a.fold) & (folds["fold"] >= 0)
+                             & ~folds[inner_col]].to_numpy()
+    subset_info = None
+    if a.train_n:
+        # learning curve: keep a stratified, nested subset of the training donors (inner-validation and test
+        # rows unchanged).  Each stratum is permuted once by --subset-seed, so smaller subsets are prefixes of
+        # larger ones; allocation is proportional to stratum size with at least one donor per stratum.
+        grp = folds.loc[train_rows, "group"].astype(str)
+        strata = (grp.str.contains(a.strata_regex, regex=True) if a.strata_regex
+                  else pd.Series(True, index=grp.index)).to_numpy()
+        srng = np.random.default_rng(a.subset_seed)
+        labels = sorted(set(strata.tolist()))
+        perm = {s: train_rows[strata == s][srng.permutation(int((strata == s).sum()))] for s in labels}
+        n = min(int(a.train_n), len(train_rows))
+        sizes = {s: len(perm[s]) for s in labels}
+        alloc = {s: max(1, int(np.floor(n * sizes[s] / len(train_rows)))) for s in labels}
+        while sum(alloc.values()) < n:
+            s = max(labels, key=lambda s: n * sizes[s] / len(train_rows) - alloc[s])
+            alloc[s] += 1
+        while sum(alloc.values()) > n:
+            s = max((s for s in labels if alloc[s] > 1), key=lambda s: alloc[s])
+            alloc[s] -= 1
+        train_rows = np.sort(np.concatenate([perm[s][:alloc[s]] for s in labels]))
+        subset_info = {"train_n": int(n), "subset_seed": a.subset_seed, "strata_regex": a.strata_regex,
+                       "allocation": {str(k): int(v) for k, v in alloc.items()}}
+    if set(test_rows) & (set(inner_rows) | set(train_rows)):
+        raise SystemExit("test rows overlap training rows")
+    if set(folds.loc[test_rows, "donor_id"]) & set(folds.loc[np.r_[train_rows, inner_rows], "donor_id"]):
+        raise SystemExit("a test donor also appears in training")
+
+    cells = Cells(a.dataset_dir / "cells_panel6k.npz", bundle.gene_ids)
+    z = np.load(a.dataset_dir / "cells_panel6k.npz", allow_pickle=False)
+    panel_measured = z["panel_measured"].astype(bool)
+    if not np.array_equal(panel_measured, ext.output_availability_mask.astype(bool)):
+        raise SystemExit("cells' measured panel differs from the condition NPZ output_availability_mask")
+
+    base = torch.from_numpy(ext.base_conditions.astype(np.float32)).to(device)
+    bulk_frac = torch.from_numpy(ext.bulk_measurement_fraction.astype(np.float32)).to(device)
+    avail_rows = torch.from_numpy(ext.output_availability_mask.astype(bool)).to(device)
+    cond_rows = condition_with_measurement_context(base, bulk_frac, avail_rows)   # [rows, condition_dim]
+
+    denoiser = diffusion.denoiser
+    info = set_trainable(denoiser, a.mode, a.lora_rank, a.lora_alpha)
+    params = [p for p in denoiser.parameters() if p.requires_grad]
+    named = [(n, p) for n, p in denoiser.named_parameters() if p.requires_grad]
+    opt = torch.optim.AdamW(params, lr=a.lr, weight_decay=0.0)
+    ema = {n: p.detach().clone() for n, p in named}
+    log(f"mode={a.mode} trainable={info['n_trainable']:,} rows train/inner/test="
+        f"{len(train_rows)}/{len(inner_rows)}/{len(test_rows)} cells(train)={int(cells.count[train_rows].sum()):,}")
+
+    # fixed inner-validation draws
+    vrng = np.random.default_rng(a.seed + 1)
+    val_cells, val_rows = [], []
+    for r in inner_rows:
+        n = int(cells.count[r])
+        take = min(a.val_cells_per_row, n)
+        pick = cells.start[r] + np.sort(vrng.choice(n, size=take, replace=False))
+        val_cells.append(pick)
+        val_rows.append(np.full(take, r))
+    val_cells = np.concatenate(val_cells) if val_cells else np.zeros(0, np.int64)
+    val_rows = np.concatenate(val_rows) if val_rows else np.zeros(0, np.int64)
+
+    def to_batch(r: np.ndarray, c: np.ndarray):
+        x_log = torch.from_numpy(np.log1p(cells.dense(c))).to(device)
+        rr = torch.from_numpy(r).to(device)
+        availability = avail_rows[rr]
+        return scaler.to_unit_tensor(x_log), cond_rows[rr], availability, x_log > 0
+
+    def swap_in_ema() -> dict:
+        backup = {n: p.detach().clone() for n, p in named}
+        with torch.no_grad():
+            for n, p in named:
+                p.copy_(ema[n])
+        return backup
+
+    def restore(backup: dict) -> None:
+        with torch.no_grad():
+            for n, p in named:
+                p.copy_(backup[n])
+
+    @torch.no_grad()
+    def val_loss() -> float:
+        if len(val_cells) == 0:
+            return float("nan")
+        diffusion.eval()
+        tot, n = 0.0, 0
+        for rep in range(a.val_repeats):
+            for i in range(0, len(val_cells), a.batch_size):
+                g = torch.Generator(device=device).manual_seed(a.seed + 1_000_003 * rep + i)
+                v, c, m, act = to_batch(val_rows[i:i + a.batch_size], val_cells[i:i + a.batch_size])
+                with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=device.type == "cuda"):
+                    res = diffusion.training_loss(v, c, availability_mask=m, active_target=act, generator=g)
+                tot += float(res.loss) * v.shape[0]
+                n += v.shape[0]
+        diffusion.train()
+        return tot / max(n, 1)
+
+    history = []
+    best = {"loss": val_loss(), "step": 0}
+    best_state = {n: t.detach().cpu().clone() for n, t in ema.items()}
+    history.append({"step": 0, "inner_val_loss": best["loss"], "train_loss": None})
+    log(f"step 0 inner-val loss {best['loss']:.5f} (pretrained)")
+    gen = torch.Generator(device=device).manual_seed(a.seed + 7)
+    diffusion.train()
+    t0 = time.time()
+    run_loss, run_n, bad = 0.0, 0, 0
+    max_steps = 20 if a.smoke else (a.fixed_steps or a.max_steps)
+    eval_every = 5 if a.smoke else a.eval_every
+    step = 0
+    for step in range(1, max_steps + 1):
+        for gparam in opt.param_groups:
+            gparam["lr"] = a.lr * min(1.0, step / max(1, a.warmup))
+        r, c = draw_batch(cells, train_rows, a.batch_size, rng)
+        v, cond, m, act = to_batch(r, c)
+        opt.zero_grad(set_to_none=True)
+        with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=device.type == "cuda"):
+            res = diffusion.training_loss(v, cond, availability_mask=m, active_target=act, generator=gen)
+        if not bool(torch.isfinite(res.loss)):
+            raise FloatingPointError(f"non-finite loss at step {step}")
+        res.loss.backward()
+        norm = nn.utils.clip_grad_norm_(params, 5.0)
+        if not bool(torch.isfinite(norm)):
+            raise FloatingPointError(f"non-finite grad norm at step {step}")
+        opt.step()
+        with torch.no_grad():
+            for n_, p in named:
+                ema[n_].lerp_(p.detach(), 1.0 - a.ema_decay)
+        run_loss += float(res.loss.detach())
+        run_n += 1
+        if a.fixed_steps and step == max_steps:
+            best = {"loss": float("nan"), "step": step}
+            best_state = {n_: t.detach().cpu().clone() for n_, t in ema.items()}
+        if step % eval_every == 0 and not a.fixed_steps:
+            backup = swap_in_ema()
+            vl = val_loss()
+            restore(backup)
+            rec = {"step": step, "inner_val_loss": vl, "train_loss": run_loss / run_n,
+                   "sec": round(time.time() - t0, 1)}
+            history.append(rec)
+            run_loss, run_n = 0.0, 0
+            if vl < best["loss"] - 1e-6:
+                best = {"loss": vl, "step": step}
+                best_state = {n_: t.detach().cpu().clone() for n_, t in ema.items()}
+                bad = 0
+            else:
+                bad += 1
+            log(f"step {step} train {rec['train_loss']:.5f} inner-val {vl:.5f} best {best['loss']:.5f}@{best['step']} "
+                f"({rec['sec']:.0f}s)")
+            (a.out_dir / "history.json").write_text(json.dumps(history, indent=1))
+            if bad >= a.patience:
+                log(f"early stop: no improvement in {a.patience} evaluations")
+                break
+
+    # load the selected EMA state, merge LoRA, save a self-contained checkpoint
+    with torch.no_grad():
+        for n_, p in named:
+            p.copy_(best_state[n_].to(device))
+    if a.mode == "lora":
+        merge_lora(denoiser)
+    state = {k: v.detach().cpu().clone() for k, v in denoiser.state_dict().items()}
+    payload_in = SS._load_checkpoint_cpu(a.checkpoint)
+    ref_state = payload_in["ema_state"]["model_state"]
+    if set(ref_state.keys()) != set(state.keys()):
+        raise SystemExit("fine-tuned state keys differ from the checkpoint's")
+    changed = {k: float((state[k].float() - ref_state[k].float()).abs().max()) for k in state}
+    out = {k: payload_in[k] for k in KEEP_KEYS if k in payload_in}
+    out["model_state"] = state
+    out["ema_state"] = {"model_state": state}
+    ft_meta = {
+        "schema": SCHEMA, "source_checkpoint": str(a.checkpoint), "source_checkpoint_sha256": got,
+        "dataset_dir": str(a.dataset_dir), "condition_npz": str(a.condition_npz),
+        "condition_npz_sha256": ext.input_sha256, "fold": a.fold, "mode": a.mode, "trainable": info,
+        "lr": a.lr, "warmup": a.warmup, "batch_size": a.batch_size, "ema_decay": a.ema_decay,
+        "max_steps": max_steps, "steps_run": step, "eval_every": eval_every, "patience": a.patience,
+        "train_subset": subset_info, "train_donors_file": a.train_donors_file or None,
+        "support_manifest": str(a.support_manifest) if support else None,
+        "support_sha256": support["sha256"] if support else None,
+        "train_donor_ids": support["train_donor_ids"] if support else None,
+        "excluded_selected_donor_visits": support["excluded_sample_ids"] if support else None,
+        "fixed_steps": a.fixed_steps or None,
+        "selected_step": best["step"], "selected_inner_val_loss": best["loss"],
+        "pretrained_inner_val_loss": history[0]["inner_val_loss"],
+        "train_rows": [str(x) for x in folds.loc[train_rows, "sample_id"]],
+        "inner_val_rows": [str(x) for x in folds.loc[inner_rows, "sample_id"]],
+        "test_rows_never_loaded_for_training": [str(x) for x in folds.loc[test_rows, "sample_id"]],
+        "max_abs_weight_change": max(changed.values()),
+        "n_tensors_changed": int(sum(v > 0 for v in changed.values())),
+        "seed": a.seed, "wall_seconds": round(time.time() - t0, 1),
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+    }
+    out["finetune"] = ft_meta
+    tmp = a.out_dir / "checkpoint_ft.pt.tmp"
+    torch.save(out, tmp)
+    os.replace(tmp, done)
+    ft_meta["checkpoint_sha256"] = sha256_file(done)
+    # reload through the sampler's own restore path and compare one forward pass
+    check = SS.restore_standalone(done, device=torch.device("cpu"), weights="ema", conditioner_source="embedded")
+    ref = SS.restore_standalone(done, device=torch.device("cpu"), weights="raw", conditioner_source="embedded")
+    xs = torch.randn(4, check.diffusion.state_dim, generator=torch.Generator().manual_seed(0))
+    tt = torch.full((4,), 0.5)
+    cc = cond_rows[torch.from_numpy(train_rows[:1]).to(device)].repeat(4, 1).float().cpu()
+    denoiser_cpu = denoiser.to("cpu").float().eval()
+    with torch.no_grad():
+        o1 = check.diffusion.denoiser(xs, tt, cc).value_prediction
+        o2 = denoiser_cpu(xs, tt, cc).value_prediction
+        o3 = ref.diffusion.denoiser(xs, tt, cc).value_prediction
+    ft_meta["reload_forward_max_abs_diff"] = float(max((o1 - o2).abs().max(), (o1 - o3).abs().max()))
+    if ft_meta["reload_forward_max_abs_diff"] > 1e-4:
+        raise SystemExit(f"reloaded checkpoint differs: {ft_meta['reload_forward_max_abs_diff']}")
+    (a.out_dir / "history.json").write_text(json.dumps(history, indent=1))
+    (a.out_dir / "RUN.json").write_text(json.dumps(ft_meta, indent=1))
+    log(f"saved {done} (selected step {best['step']}, inner-val {best['loss']:.5f} vs pretrained "
+        f"{history[0]['inner_val_loss']:.5f}); sha {ft_meta['checkpoint_sha256'][:12]}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())