Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T063808Z-no-pretraining-ablation-f0/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/ft_sdd_aug.py

@@ -0,0 +1,530 @@
+#!/usr/bin/env python3
+"""Fine-tune the final PBISC-SDD model inside one paired dataset fold (augmentation variant of ft_sdd.py).
+
+Adds two optional training augmentations; with both off it trains exactly like ft_sdd.py:
+  --multi-k        each training cell sees its donor's real bulk at a recipe size K drawn from a list
+                   (per-cell depth kept), instead of the NPZ's single K
+  --recipe-frac    part of every batch comes from one pretraining-style recipe: K cells of one training donor,
+                   condition = their full-axis pseudobulk at recipe size K (needs data/<dataset>/cells_full.npz)
+Inner validation always uses the real bulk at the NPZ's K.
+
+No-pretraining ablation (added 2026-10-05; default unchanged): --init random re-initialises every denoiser weight the
+way pretraining started (a fresh ConditionalSBDDenoiser(model_config) under torch.manual_seed(--init-seed)) and trains
+it with --mode full.  The checkpoint still supplies the architecture, the 6k panel, the value scaler and the bulk
+conditioner's z-score constants (preprocessing, not learned weights).  "pretrained_inner_val_loss" in RUN.json is then
+the random-init step-0 loss; "init" records which start was used.
+
+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("--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("--multi-k", default="", help="comma list: present each real bulk at these recipe sizes K "
+                    "(per-cell depth kept); one K drawn per training cell. Inner validation stays at the NPZ's K")
+    ap.add_argument("--recipe-frac", type=float, default=0.0,
+                    help="fraction of each batch taken from one pretraining-style recipe of a training donor")
+    ap.add_argument("--recipe-k-grid", default="250,500,1000,2000,4000",
+                    help="recipe sizes K (the pretraining grid); a donor only uses K up to its own cell count")
+    ap.add_argument("--init", choices=("pretrained", "random"), default="pretrained",
+                    help="random: no-pretraining ablation, fresh denoiser weights (requires --mode full)")
+    ap.add_argument("--init-seed", type=int, default=20260627, help="torch seed of the random init (pretraining's)")
+    a = ap.parse_args(argv)
+    if a.init == "random" and a.mode != "full":
+        raise SystemExit("--init random needs --mode full (LoRA / condenc need pretrained base weights)")
+
+    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():
+        log(f"{done} exists; nothing to do")
+        return 0
+    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
+    init_info = {"init": a.init}
+    if a.init == "random":
+        from pbisc_sdd.model import ConditionalSBDDenoiser
+        torch.manual_seed(a.init_seed)
+        fresh = ConditionalSBDDenoiser(diffusion.denoiser.config)
+        diffusion.denoiser.load_state_dict(fresh.state_dict(), strict=True)
+        torch.manual_seed(a.seed)
+        init_info.update({"init_seed": a.init_seed, "n_tensors": len(fresh.state_dict()),
+                          "kept_from_checkpoint": ["model_config", "diffusion_config", "gene panel", "value_scaler",
+                                                   "conditioner z-score constants"]})
+        del fresh
+        log(f"random init of every denoiser weight (seed {a.init_seed}); no pretrained weights used")
+    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")
+    test_rows = folds.index[folds["fold"] == a.fold].to_numpy()
+    inner_rows = folds.index[folds[f"inner_val_f{a.fold}"]].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[f"inner_val_f{a.fold}"]].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]
+
+    # --- augmentation 1: the same real bulk presented at several recipe sizes K (per-cell depth kept) -------------
+    multi_k = [int(x) for x in a.multi_k.split(",") if x] if a.multi_k else []
+    cond_multi = None
+    if multi_k:
+        with np.load(a.condition_npz, allow_pickle=False) as z:
+            bulk_counts = np.asarray(z["bulk_counts"], dtype=np.float64)
+            k0 = np.asarray(z["recipe_k"], dtype=np.float64).reshape(-1)
+        stacks = []
+        for K in multi_k:
+            # the loader's arithmetic: float32 counts -> log1p -> conditioner.transform(row, K)
+            b = np.stack([bundle.conditioner.transform(
+                np.log1p(np.asarray(bulk_counts[r] * (K / k0[r]), dtype=np.float32)).astype(np.float32), int(K))
+                for r in range(bulk_counts.shape[0])]).astype(np.float32)
+            stacks.append(condition_with_measurement_context(torch.from_numpy(b).to(device), bulk_frac, avail_rows))
+        cond_multi = torch.stack(stacks)                 # [nK, rows, condition_dim]
+        for i, K in enumerate(multi_k):
+            if bool((k0 == K).all()) and not torch.allclose(cond_multi[i], cond_rows, atol=1e-5):
+                raise SystemExit(f"multi-K condition at K={K} differs from the loader's condition")
+
+    # --- augmentation 2: pretraining-style recipes from the training donors' own cells -----------------------------
+    recipe_grid = [int(x) for x in a.recipe_k_grid.split(",") if x]
+    n_rec = int(round(a.recipe_frac * a.batch_size)) if a.recipe_frac > 0 else 0
+    full = sc_valid_full = None
+    if n_rec:
+        import scipy.sparse as sp
+        zf = np.load(a.dataset_dir / "cells_full.npz", allow_pickle=False)
+        if not np.array_equal(zf["row_sample"].astype(np.int64), cells.row_sample):
+            raise SystemExit("cells_full.npz rows differ from cells_panel6k.npz rows")
+        full = sp.csr_matrix((zf["data"], zf["indices"], zf["indptr"]), shape=tuple(zf["shape"]))
+        with np.load(a.dataset_dir / "features.npz", allow_pickle=False) as fz:
+            sc_valid_full = fz["sc_valid"].astype(bool)
+        if full.shape[1] != sc_valid_full.shape[1]:
+            raise SystemExit("cells_full gene axis differs from features.npz")
+        recipe_rows = np.asarray([r for r in train_rows if cells.count[r] >= min(recipe_grid)], dtype=np.int64)
+        if recipe_rows.size == 0:
+            raise SystemExit("no training donor has enough cells for the smallest recipe size")
+        panel_pos = np.asarray(bundle.panel_positions, dtype=np.int64)
+
+    def draw_recipe():
+        """One recipe: K cells of one training donor; condition = their pseudobulk at recipe size K, as in pretraining."""
+        d = int(recipe_rows[rng.integers(0, recipe_rows.size)])
+        ks = [k for k in recipe_grid if k <= cells.count[d]]
+        K = int(ks[rng.integers(0, len(ks))])
+        idx = cells.start[d] + np.sort(rng.choice(int(cells.count[d]), size=K, replace=False))
+        pb = np.asarray(full[idx].sum(axis=0), dtype=np.float32).ravel()
+        b = bundle.conditioner.transform(np.log1p(pb).astype(np.float32), K).astype(np.float32)
+        frac = torch.from_numpy(sc_valid_full[d][panel_pos].astype(np.float32)).to(device)[None]
+        c = condition_with_measurement_context(torch.from_numpy(b).to(device)[None], frac, avail_rows[d][None])
+        tgt = rng.choice(idx, size=n_rec, replace=K < n_rec)
+        return d, tgt, c, K
+
+    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' if a.init == 'pretrained' else 'random init'})")
+    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.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 - n_rec, rng)
+        v, cond, m, act = to_batch(r, c)
+        if cond_multi is not None:
+            kidx = torch.from_numpy(rng.integers(0, len(multi_k), size=len(r))).to(device)
+            cond = cond_multi[kidx, torch.from_numpy(r).to(device)]
+        if n_rec:
+            d_r, tgt, c_r, _k = draw_recipe()
+            x_log_r = torch.from_numpy(np.log1p(cells.dense(tgt))).to(device)
+            v = torch.cat([v, scaler.to_unit_tensor(x_log_r)])
+            cond = torch.cat([cond, c_r.expand(n_rec, -1)])
+            m = torch.cat([m, avail_rows[d_r][None].expand(n_rec, -1)])
+            act = torch.cat([act, x_log_r > 0])
+        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 step % eval_every == 0:
+            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, **init_info,
+        "augmentation": {"multi_k": multi_k, "recipe_frac": a.recipe_frac, "recipe_cells_per_step": n_rec,
+                         "recipe_k_grid": recipe_grid if n_rec else 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())

paper-releases/pbisc-diffusion/updates/20261005T063808Z-no-pretraining-ablation-f0/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/run_queue_aug.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# Run a fine-tuning benchmark queue on this host's GPU, one step at a time.
+#   train|RUN_DIR|CONDITION_NPZ|FOLD|MODE|LR[|extra ft_sdd.py args ...]
+#   sample|TAG|CKPT (path, or "base")|CONDITION_NPZ|SEED|OUTPUT_NPZ
+# A train step is skipped when RUN_DIR/RUN.json exists; a sample step is skipped by sample_queue.sh when its
+# receipt and output exist.  A sample step whose CKPT is a fine-tuned run waits for that run's RUN.json and takes
+# the checkpoint sha from it.  Every GPU step goes through ml-run (ml.slice, shared GPU lock) after the thermal
+# gate and gpu_usable.sh, the same gates sample_queue.sh uses.
+#   env: QUEUE (required), DATASET_DIR (required), MAX_WAIT_H (24)
+#        GATE=thermal (2026-10-05): only the thermal gate before a step; ml-run then waits in the shared-lock flock
+#        while another job (e.g. the scSemi queue, which re-takes the lock seconds after each chunk) holds the GPU, so
+#        the two queues interleave instead of this one polling for a free lock.  Default: thermal + gpu_usable.sh.
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+TASK=$M8/plans/paired_finetune_intradataset_20260927
+SQ=$M8/plans/utility_studies_final6k_20260925/tools/sample_queue.sh
+BASE_CKPT=$M8/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt
+BASE_SHA=8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633
+PY=/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python
+QUEUE="${QUEUE:?QUEUE}"; DATASET_DIR="${DATASET_DIR:?DATASET_DIR}"; MAX_WAIT_H="${MAX_WAIT_H:-24}"
+mkdir -p "$TASK/logs"
+LOG=$TASK/logs/run_queue_$(basename "$QUEUE" .txt)_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+start=$(date +%s)
+GATE="${GATE:-default}"
+gate() {
+  if [[ $GATE == thermal ]]; then
+    until verdict=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh"); do
+      (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: thermal gate not passed within ${MAX_WAIT_H} h"; exit 1; }
+      sleep 60
+    done
+    echo "$verdict; GPU via ml-run flock"
+    return
+  fi
+  until verdict=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh") \
+        && usable=$(bash "$M8/plans/arch_ablation_6k_20260913/tools/gpu_usable.sh" 2>/dev/null); do
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 120
+  done
+  echo "$verdict; GPU $usable"
+}
+n_fail=0
+while IFS= read -r line; do
+  [[ -z "${line// }" || "$line" == \#* ]] && continue
+  IFS='|' read -r kind rest <<< "$line"
+  if [[ $kind == train ]]; then
+    IFS='|' read -r _ run cond fold mode lr extra <<< "$line"
+    if [[ -s "$run/RUN.json" ]]; then log "train $run done already; skipped"; continue; fi
+    mkdir -p "$run"
+    log "--- train $(basename "$(dirname "$run")")/$(basename "$run") mode=$mode lr=$lr ($(gate))"
+    # shellcheck disable=SC2086
+    if "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+         OMP_NUM_THREADS=4 PYTHONUNBUFFERED=1 "$PY" -u "$TASK/tools/ft_sdd_aug.py" --checkpoint "$BASE_CKPT" \
+         --checkpoint-sha "$BASE_SHA" --dataset-dir "$DATASET_DIR" --condition-npz "$cond" --fold "$fold" \
+         --mode "$mode" --lr "$lr" --out-dir "$run" ${extra//|/ } >> "$run/train.log" 2>&1; then
+      log "train $run done: $(python3 -c "import json;d=json.load(open('$run/RUN.json'));print('step',d['selected_step'],'val %.5f (pre %.5f)'%(d['selected_inner_val_loss'],d['pretrained_inner_val_loss']),d['checkpoint_sha256'][:12])")"
+    else
+      n_fail=$((n_fail+1)); log "WARN: train $run failed (see $run/train.log)"
+    fi
+  elif [[ $kind == sample ]]; then
+    IFS='|' read -r _ tag ckpt cond seed out <<< "$line"
+    if [[ $ckpt == base ]]; then ck=$BASE_CKPT; sha=$BASE_SHA
+    else
+      rj=$(dirname "$ckpt")/RUN.json
+      [[ -s $rj ]] || { log "WARN: $tag: $rj missing (training failed?); skipped"; n_fail=$((n_fail+1)); continue; }
+      ck=$ckpt; sha=$(python3 -c "import json;print(json.load(open('$rj'))['checkpoint_sha256'])")
+    fi
+    q=$(mktemp "$TASK/logs/q_${tag}_XXXX.txt"); echo "$tag|$cond|$seed|$out" > "$q"
+    CKPT=$ck CKPT_SHA=$sha QUEUE=$q MAX_WAIT_H=$MAX_WAIT_H bash "$SQ" >> "$LOG" 2>&1 || { n_fail=$((n_fail+1)); log "WARN: sample $tag failed"; }
+    rm -f "$q"
+    [[ -s ${out%.npz}.log ]] && log "sample $tag done"
+  else
+    log "WARN: unknown line: $line"
+  fi
+done < "$QUEUE"
+log "queue finished: failed=$n_fail"
+(( n_fail == 0 ))

paper-releases/pbisc-diffusion/updates/20261005T063808Z-no-pretraining-ablation-f0/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/score_scratch.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# No-pretraining ablation (2026-10-05): score the finished --init random fold-0 arms of ye2026_sepsis together with the
+# fold-0 comparison arms in ONE score_ft.py call (same scorer version, same 17 test donors, same reference view and
+# contrast; the comparison arms' fold-0 scores predate the DEG score).  Comparison NPZs live on spark-0110; pass a
+# local staging dir holding sha-checked copies plus their generation receipts (<arm>.npz + <arm>.log).
+# usage: score_scratch.sh STAGING_DIR      -> scores/ye2026_sepsis/fold0_scratch_20261005/
+set -euo pipefail
+TASK=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+STAGE=$1
+G=$TASK/generated/ye2026_sepsis/fold0
+OUT=$TASK/scores/ye2026_sepsis/fold0_scratch_20261005
+args=()
+for a in zs__raw lora_n5__raw real_lora__raw lora_recipe__raw real_full__raw; do
+  [[ -s $STAGE/$a.npz && -s $STAGE/$a.log ]] || { echo "missing staged $a"; exit 2; }
+  args+=(--arm "$a=$STAGE/$a.npz")
+done
+for a in scratch_full__raw scratch_n5__raw scratch_recipe__raw; do
+  [[ -s $G/$a.npz && -s $G/$a.log ]] && grep -q '"output_sha256"' "$G/$a.log" && args+=(--arm "$a=$G/$a.npz") \
+    || echo "not finished yet: $a"
+done
+read -r -a cargs <<< "$(bash "$TASK/tools/contrast_args.sh" ye2026_sepsis)"
+mkdir -p "$OUT"
+echo "scoring ${#args[@]} arg(s) -> $OUT"
+bash "$TASK/tools/run_unit.sh" "score-sepsis-f0-scratch" 8 "$PY" "$TASK/tools/score_ft.py" --dataset ye2026_sepsis \
+  --out "$OUT" --threads 8 "${args[@]}" "${cargs[@]}"

paper-releases/pbisc-diffusion/updates/20261005T063808Z-no-pretraining-ablation-f0/diffusion/dataset/server_1/model8/plans/utility_studies_final6k_20260925/tools/sample_queue.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# Sample a list of condition sets from the final model (0.1%-floor 6k panel, 1x, part 16) one after
+# another on this host's GPU. Every set uses the same checkpoint, sampler, step count and read-out;
+# a set differs from the others only in its condition NPZ and seed, both written in the queue file.
+#
+#   MOVE_TO_REMOTE: optional ssh host; each finished NPZ + receipt is copied to the same path there and the local NPZ
+#   is deleted only after the remote sha256 equals the receipt (a .moved marker is left locally)
+#   OVERRIDE_CELLS: optional, cells generated per bulk for every set of the queue (cells are drawn independently,
+#   so this changes precision, not the distribution)
+# Queue file: one set per line, "tag|condition_npz|seed|output_npz"; blank lines and # comments skipped.
+# A set whose output NPZ and receipt already exist is skipped, so a rerun resumes where it stopped.
+# Every GPU step goes through ml-run and waits for gpu_usable.sh and the thermal gate first.
+#
+#   env: QUEUE (required), CKPT (default: final 6k part 16), CKPT_SHA (checked before any sampling),
+#        STEPS (50), READOUT (bernoulli), THR (0.0), MAX_WAIT_H (24)
+#        GATE=thermal (2026-10-05): thermal gate only; ml-run then waits in the shared-lock flock while another job
+#        holds the GPU (interleaves with a queue that re-takes the lock between chunks).  Default: + gpu_usable.sh.
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+PLAN=$M8/plans/utility_studies_final6k_20260925
+QUEUE="${QUEUE:?QUEUE}"
+CKPT="${CKPT:-$M8/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt}"
+CKPT_SHA="${CKPT_SHA:-8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633}"
+STEPS="${STEPS:-50}"; READOUT="${READOUT:-bernoulli}"; THR="${THR:-0.0}"; MAX_WAIT_H="${MAX_WAIT_H:-24}"
+for cand in /home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python \
+            /home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python; do
+  [[ -x "$cand" ]] && { PY=$cand; break; }
+done
+mkdir -p "$PLAN/logs"
+LOG=$PLAN/logs/sample_queue_$(basename "$QUEUE" .txt)_$(hostname -s)_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+start=$(date +%s)
+
+[[ -s "$CKPT" ]] || { log "ABORT: checkpoint missing: $CKPT"; exit 1; }
+got=$(sha256sum "$CKPT" | cut -d' ' -f1)
+[[ "$got" == "$CKPT_SHA" ]] || { log "ABORT: checkpoint sha ${got:0:12} != expected ${CKPT_SHA:0:12}"; exit 1; }
+log "queue=$QUEUE ckpt=$(basename "$CKPT") sha=${got:0:12} steps=$STEPS readout=$READOUT thr=$THR py=$PY"
+
+n_ok=0; n_fail=0
+while IFS='|' read -r tag cond seed out; do
+  [[ -z "${tag// }" || "$tag" == \#* ]] && continue
+  rec=${out%.npz}.log; err=${out%.npz}.err
+  if [[ -s "$rec" && ( -s "$out" || -f "${out%.npz}.moved" ) ]]; then log "$tag already sampled; skipped"; continue; fi
+  [[ -s "$cond" ]] || { log "WARN: $tag condition missing: $cond"; n_fail=$((n_fail+1)); continue; }
+  mkdir -p "$(dirname "$out")"
+  until verdict=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh") \
+        && { [[ "${GATE:-default}" == thermal ]] && usable="via ml-run flock" \
+             || usable=$(bash "$M8/plans/arch_ablation_6k_20260913/tools/gpu_usable.sh" 2>/dev/null); }; do
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 120
+  done
+  log "--- $tag seed=$seed ($verdict; GPU $usable)"
+  if "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+       PYTHONPATH="$M8/src" OMP_NUM_THREADS=4 "$PY" -u "$M8/scripts/sample_sdd_standalone.py" \
+       --checkpoint "$CKPT" --condition-npz "$cond" --output "$out" --weights ema --batch-size 256 \
+       --steps "$STEPS" --seed "$seed" --device cuda --conditioner-source embedded \
+       --active-logit-threshold "$THR" --support-readout "$READOUT" \
+       ${OVERRIDE_CELLS:+--override-cells-per-bulk "$OVERRIDE_CELLS"} > "$rec" 2> "$err"; then
+    n_ok=$((n_ok+1))
+    log "$tag done: $(python3 -c "import json;d=json.load(open('$rec'));print('cells', d.get('generated_counts_rows','?'), 'zero_frac %.4f' % d.get('generated_zero_fraction',-1), d.get('output_sha256','')[:12])" 2>/dev/null || echo "see $rec")"
+    if [[ -n "${MOVE_TO_REMOTE:-}" ]]; then
+      # keep this host's disk free: copy the NPZ and its receipt to the same path on the remote host,
+      # and delete the local NPZ only when the remote sha256 equals the receipt's output_sha256
+      want=$(python3 -c "import json;print(json.load(open('$rec')).get('output_sha256',''))" 2>/dev/null)
+      ssh -n "$MOVE_TO_REMOTE" "mkdir -p '$(dirname "$out")'" && \
+        ionice -c3 rsync -a --bwlimit=200000 "$out" "$rec" "$MOVE_TO_REMOTE:$(dirname "$out")/" >> "$LOG" 2>&1
+      got=$(ssh -n "$MOVE_TO_REMOTE" "sha256sum '$out' 2>/dev/null" | cut -d' ' -f1)
+      if [[ -n "$want" && "$want" == "$got" ]]; then
+        rm -f "$out"; echo "moved to $MOVE_TO_REMOTE (sha ${got:0:12}) $(date +%FT%T)" > "${out%.npz}.moved"
+        log "$tag moved to $MOVE_TO_REMOTE, local NPZ removed (sha ${got:0:12})"
+      else
+        log "WARN: $tag remote copy sha ${got:0:12} != receipt ${want:0:12}; local NPZ kept"
+      fi
+    fi
+  else
+    n_fail=$((n_fail+1))
+    log "WARN: $tag failed (see $err); receipt removed so a rerun retries it"
+    rm -f "$rec"
+  fi
+done < "$QUEUE"
+log "queue finished: ok=$n_ok failed=$n_fail"
+(( n_fail == 0 ))