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/tools/compat_patch_20260928.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Compatibility addition 2026-09-28: a size-1 trailing training batch (CPU only; no computation is run).
+
+Problem: vaegan.fastgenerator.train() builds scvi DataSplitter(train_size=1.0, batch_size=B) with drop_last False.
+When n_obs % B == 1 the last training minibatch holds one cell and the encoder's BatchNorm1d raises
+"Expected more than 1 value per channel when training" (pretrain B = 128; inference B = min(n, 9000)).
+Upstream anticipated this: the same train() carries a commented-out branch that switches to a drop-last splitter
+(DataSplitter2, itself dead code) exactly when n_obs % batch_size == 1.
+
+Change (vaegan.py, marker SCSEMI_COMPAT_20260928): in that case only, pass scvi's supported DataSplitter option
+drop_last=True (scvi 1.4.1 pops it and applies it to the training loader only; validate_data_split then keeps
+n_train = n_obs).  Every other cell count takes the byte-identical original call, so unaffected representatives
+compute exactly as before.  No cell is removed from the data: each epoch reshuffles all n cells and the one cell
+left over by the batch grid is skipped for that epoch.
+
+Updates, each by atomic replace, under an exclusive lock on scsemi/.code_update.lock (the runner holds a shared
+lock while it verifies vendor hashes and imports the vendor):
+  vendor/scSemiProfiler/scSemiProfiler/vaegan.py, vendor/compatibility.patch (git diff vs the pinned commit),
+  vendor/source_manifest.json (file hashes, patch hash, changes list); the previous manifest is kept as
+  vendor/source_manifest.before_20260928.json.  Idempotent: an already-patched, consistent vendor is left alone.
+usage: compat_patch_20260928.py [--vendor DIR] [--no-lock]
+"""
+from __future__ import annotations
+
+import argparse
+import fcntl
+import hashlib
+import json
+import os
+import subprocess
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parents[1]
+COMMIT = "c2aea021188759e56ecf14578915c0237aaa75d2"
+MARK = "# SCSEMI_COMPAT_20260928"
+CHANGE = ("drop a size-1 trailing training batch: scvi DataSplitter(drop_last=True) only when n_obs % batch_size "
+          "== 1 (upstream's own commented-out remedy); all other cell counts unchanged")
+OLD = """        data_splitter = DataSplitter(
+            self.adata_manager,
+            train_size=1.0,
+            validation_size=0,
+            batch_size=batch_size,)
+"""
+NEW = """        # SCSEMI_COMPAT_20260928: upstream's commented-out remedy above (a drop-last splitter when
+        # n_obs % batch_size == 1), through scvi's supported DataSplitter option: drop the trailing training
+        # batch only when it would hold a single cell (BatchNorm cannot train on one sample).  Every other
+        # cell count takes the original call unchanged.
+        if self.adata.n_obs % batch_size == 1:
+            data_splitter = DataSplitter(
+                self.adata_manager,
+                train_size=1.0,
+                validation_size=0,
+                batch_size=batch_size,
+                drop_last=True,)
+        else:
+            data_splitter = DataSplitter(
+                self.adata_manager,
+                train_size=1.0,
+                validation_size=0,
+                batch_size=batch_size,)
+"""
+
+
+def sha(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()
+
+
+def atomic_write(path: Path, data: bytes) -> None:
+    tmp = path.with_name(f".{path.name}.tmp{os.getpid()}")
+    with open(tmp, "wb") as f:
+        f.write(data)
+        f.flush()
+        os.fsync(f.fileno())
+    os.replace(tmp, path)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--vendor", type=Path, default=HERE / "vendor")
+    ap.add_argument("--no-lock", action="store_true", help="staging copies only")
+    a = ap.parse_args()
+    vendor = a.vendor.resolve()
+    repo = vendor / "scSemiProfiler"
+    if subprocess.check_output(["git", "-C", str(repo), "rev-parse", "HEAD"], text=True).strip() != COMMIT:
+        raise SystemExit("refuse: vendor is not at the pinned commit")
+    if not a.no_lock and vendor != (HERE / "vendor").resolve():
+        raise SystemExit("--no-lock is required for a vendor outside scsemi/vendor")
+    lock = None
+    if not a.no_lock:
+        lock = open(HERE / ".code_update.lock", "a")
+        fcntl.flock(lock, fcntl.LOCK_EX)
+    try:
+        man_path = vendor / "source_manifest.json"
+        man = json.loads(man_path.read_text())
+        vg = repo / "scSemiProfiler/vaegan.py"
+        text = vg.read_text()
+        on_disk = {n: sha((repo / n).read_bytes()) for n in man["files"]}
+        if MARK in text:
+            if on_disk == man["files"] and CHANGE in man["changes"]:
+                print(json.dumps({"status": "already patched", "vaegan_sha256": on_disk["scSemiProfiler/vaegan.py"]}))
+                return 0
+            raise SystemExit("vaegan.py carries the marker but the manifest is inconsistent; inspect")
+        if on_disk != man["files"]:
+            raise SystemExit("vendor files differ from source_manifest.json before patching; inspect")
+        if text.count(OLD) != 1:
+            raise SystemExit("expected exactly one DataSplitter call in vaegan.train()")
+        atomic_write(vendor / "source_manifest.before_20260928.json", man_path.read_bytes())
+        atomic_write(vg, text.replace(OLD, NEW).encode())
+        diff = subprocess.check_output(["git", "-C", str(repo), "diff", "--", "scSemiProfiler/vaegan.py",
+                                        "scSemiProfiler/fast_generator.py"])
+        atomic_write(vendor / "compatibility.patch", diff)
+        new = dict(man)
+        new["compatibility_patch_sha256"] = sha(diff)
+        new["changes"] = list(man["changes"]) + [CHANGE]
+        new["files"] = {str(p.relative_to(repo)): sha(p.read_bytes()) for p in sorted((repo / "scSemiProfiler").glob("*.py"))}
+        new["previous_manifest_sha256"] = sha((vendor / "source_manifest.before_20260928.json").read_bytes())
+        atomic_write(man_path, (json.dumps(new, indent=2) + "\n").encode())
+        print(json.dumps({"status": "patched", "vaegan_sha256": new["files"]["scSemiProfiler/vaegan.py"],
+                          "patch_sha256": new["compatibility_patch_sha256"],
+                          "source_canonical_sha256": sha(json.dumps(new, sort_keys=True).encode()),
+                          "previous_source_canonical_sha256": sha(json.dumps(man, sort_keys=True).encode())}))
+    finally:
+        if lock is not None:
+            fcntl.flock(lock, fcntl.LOCK_UN)
+            lock.close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# CPU-only step as a transient systemd user unit in ml.slice (server_1 and server_2; same paths on both).
+#   MemoryMax <= 16G, MemorySwapMax 0, OOMPolicy kill, OOMScoreAdjust +500, CPUQuota = THREADS x 100 % (<= 6),
+#   Nice 10, CUDA hidden, no bytecode.  PYTHONNOUSERSITE=1 unless ALLOW_USER_SITE=1 (the frozen server_1 runtime_env
+#   takes certifi / charset_normalizer from ~/.local, exactly as the frozen campaign ran).  Refuses to start unless MemAvailable >= 32 GiB + MEMMAX (the co-scheduled
+#   trainer keeps a 32 GiB floor).  Waits; returns the command's exit code (last log line "UNIT_EXIT <rc>").
+# usage: cpu_unit.sh NAME THREADS MEMMAX_GIB COMMAND [ARG ...]     log -> scsemi/logs/NAME_<stamp>.log
+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}"
+S=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi
+name=$1; thr=$2; mem=$3; shift 3
+(( thr >= 1 && thr <= 6 )) || { echo "THREADS must be 1..6" >&2; exit 2; }
+(( mem >= 1 && mem <= 16 )) || { echo "MEMMAX_GIB must be 1..16" >&2; exit 2; }
+avail=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo)
+(( avail >= 32 + mem )) || { echo "MemAvailable ${avail} GiB < $((32 + mem)); not starting $name" >&2; exit 3; }
+systemctl --user is-active --quiet ml-memory-guard.service || { echo "memory guard inactive; not starting $name" >&2; exit 4; }
+mkdir -p "$S/logs"
+if [[ "${ALLOW_USER_SITE:-0}" == 1 ]]; then nousersite=; else nousersite=1; fi
+stamp=$(date +%Y%m%dT%H%M%S)
+unit=scsemi-${name}-${stamp}
+log=$S/logs/${name}_${stamp}.log
+echo -e "$(date -Is)\tstart\t$unit\t$(hostname -s)\tMemAvailable=${avail}GiB\tthreads=$thr\tmem=${mem}G\t$*" >> "$S/logs/units.tsv"
+systemd-run --user --unit="$unit" --slice=ml.slice --working-directory="$S" --expand-environment=no \
+  -p MemoryMax="${mem}G" -p MemorySwapMax=0 -p OOMPolicy=kill -p OOMScoreAdjust=500 \
+  -p CPUQuota=$((thr * 100))% -p Nice=10 -p Restart=no \
+  -p StandardOutput=append:"$log" -p StandardError=append:"$log" \
+  --setenv=CUDA_VISIBLE_DEVICES= --setenv=PYTHONNOUSERSITE="$nousersite" --setenv=PYTHONDONTWRITEBYTECODE=1 \
+  --setenv=PYTHONUNBUFFERED=1 --setenv=OMP_NUM_THREADS="$thr" --setenv=OPENBLAS_NUM_THREADS="$thr" \
+  --setenv=MKL_NUM_THREADS="$thr" --setenv=NUMBA_NUM_THREADS="$thr" --setenv=NUMEXPR_NUM_THREADS="$thr" \
+  /bin/bash -c '"$@"; rc=$?; echo "UNIT_EXIT $rc"; exit $rc' _ "$@" >/dev/null
+echo "unit=$unit log=$log"
+sleep 3
+while [[ "$(systemctl --user show "$unit" -p ActiveState --value 2>/dev/null)" =~ ^(active|activating|deactivating)$ ]]; do sleep 10; done
+rc=$(tail -n 1 "$log" | awk '$1=="UNIT_EXIT"{print $2}')
+rc=${rc:-255}
+[[ $rc == 255 ]] && echo "no UNIT_EXIT line (killed? OOM?): $(systemctl --user show "$unit" -p Result --value 2>/dev/null)" >> "$log"
+systemctl --user reset-failed "$unit" >/dev/null 2>&1 || true
+echo -e "$(date -Is)\tend\t$unit\trc=$rc" >> "$S/logs/units.tsv"
+echo "unit $unit finished rc=$rc"
+exit "$rc"

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

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+"""Adapter: completed scSemiProfiler target shards -> the benchmark's generated NPZ + JSON receipt (CPU only).
+
+Per target (condition-NPZ order):
+  cells  upstream output has one generated cell per cell of the assigned representative (n_rep cells).
+         Keep 1,500: n_rep >= 1500 -> 1,500 drawn without replacement; n_rep < 1500 -> whole permutations of the
+         n_rep cells concatenated until 1,500 (each cell used floor/ceil(1500/n_rep) times).  Stream
+         default_rng([20260927, uint64(sha256(target)[:8])]) (the scorer's donor-keyed stream form); kept rows sorted.
+  depth  upstream values are normalized expression (library-normalised ZINB means, values <= 10 zeroed).  Each kept
+         cell is rescaled to sum to D = the median per-cell UMI on the modeled genes of the representatives'
+         observed cells (inputs_manifest depth.value; label-free, from the training pairs only).  All-zero cells stay
+         zero (counted).  Result = expected counts (Poisson rates), what score_ft.py reads out.
+  genes  modeled genes placed at their 6k-panel columns; every other panel column is 0.
+metadata_json.input_condition_path = the split's test_raw.npz, so the scorer's bulk-broadcast baseline works.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+PANEL = M8 / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/selected_genes.csv"
+SEED = 20260927
+N_CELLS = 1500
+
+
+def sha(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 target_rng(target: str) -> np.random.Generator:
+    key = int.from_bytes(hashlib.sha256(str(target).encode()).digest()[:8], "little")
+    return np.random.default_rng([SEED, key])
+
+
+def pick_rows(n_src: int, target: str, n_out: int = N_CELLS) -> np.ndarray:
+    if n_src < 1:
+        raise ValueError(f"{target}: no generated cells")
+    rng = target_rng(target)
+    if n_src >= n_out:
+        return np.sort(rng.choice(n_src, size=n_out, replace=False))
+    reps = math.ceil(n_out / n_src)
+    return np.sort(np.concatenate([rng.permutation(n_src) for _ in range(reps)])[:n_out])
+
+
+def to_expected_counts(X: np.ndarray, depth: float) -> tuple[np.ndarray, int]:
+    lib = X.sum(1, dtype=np.float64)
+    scale = np.divide(depth, lib, out=np.zeros_like(lib), where=lib > 0)
+    return (X * scale[:, None]).astype(np.float32), int((lib <= 0).sum())
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--work", type=Path, required=True)
+    ap.add_argument("--out", type=Path, required=True, help="generated NPZ path (receipt = same stem .log)")
+    a = ap.parse_args(argv)
+    work, out = a.work.resolve(), a.out.resolve()
+    man = json.loads((work / "inputs/inputs_manifest.json").read_text())
+    run = json.loads((work / "run_manifest.json").read_text())
+    smoke = bool(man.get("smoke"))
+    if smoke and "/scsemi/smoke/" not in str(out):
+        raise SystemExit("smoke outputs never go to the benchmark's generated/ tree")
+    if out.exists() or out.with_suffix(".log").exists():
+        raise SystemExit(f"{out} or its receipt exists; never overwrite (preserve and inspect)")
+    signature = run["run_signature"]
+    genes = man["modeled_genes"]["gene_ids"]
+    pidx = np.asarray(man["modeled_genes"]["panel_index"], dtype=np.int64)
+    panel = pd.read_csv(PANEL)
+    panel_ids = np.asarray(panel.gene_id.astype(str).tolist(), dtype=str)   # fixed-width unicode: loads with allow_pickle=False
+    panel_symbols = np.asarray(panel.gene_symbol.astype(str).tolist(), dtype=str)
+    if not np.array_equal(panel_ids[pidx], np.asarray(genes)):
+        raise SystemExit("modeled genes do not sit at the recorded panel columns")
+    depth = float(man["depth"]["value"])
+    if not (np.isfinite(depth) and depth > 0):
+        raise SystemExit("invalid depth")
+    targets = man["condition_sample_order"] if not smoke else [t for t in man["condition_sample_order"]
+                                                                  if t in set(man["target_order_test_samples"])]
+    if sorted(targets) != sorted(man["target_order_test_samples"]):
+        raise SystemExit("targets differ from the condition NPZ order")
+    per, src_rows = [], []
+    G = np.zeros((len(targets) * N_CELLS, panel_ids.size), dtype=np.float32)
+    for i, t in enumerate(targets):
+        rec = json.loads((work / "shards" / f"{t}.json").read_text())
+        shard = work / "shards" / f"{t}.npz"
+        if not rec.get("complete") or rec["run_signature"] != signature or rec["shard_sha256"] != sha(shard):
+            raise SystemExit(f"{t}: shard incomplete or receipt mismatch")
+        C = sp.load_npz(shard).tocsr()
+        if C.shape[1] != len(genes):
+            raise SystemExit(f"{t}: shard has {C.shape[1]} genes")
+        rows = pick_rows(C.shape[0], t)
+        X = C[rows].toarray().astype(np.float64)
+        if not np.isfinite(X).all() or (X < 0).any():
+            raise SystemExit(f"{t}: non-finite or negative values")
+        E, n_zero = to_expected_counts(X, depth)
+        G[i * N_CELLS:(i + 1) * N_CELLS, pidx] = E
+        src_rows.append(rows.astype(np.int32))
+        mult = np.bincount(rows, minlength=C.shape[0])
+        per.append({"sample_id": t, "representative": rec["representative"], "n_upstream_cells": int(C.shape[0]),
+                    "with_replacement": bool(C.shape[0] < N_CELLS), "max_multiplicity": int(mult.max()),
+                    "zero_library_cells": n_zero, "elapsed_seconds": rec["elapsed_seconds"],
+                    "median_nonzero_genes": float(np.median((E > 0).sum(1)))})
+    lib = G.sum(1, dtype=np.float64)
+    nz = lib > 0
+    checks = {"finite": bool(np.isfinite(G).all()), "nonnegative": bool((G >= 0).all()),
+              "zero_outside_modeled_genes": bool(not G[:, np.setdiff1d(np.arange(panel_ids.size), pidx)].any()),
+              "nonzero_cells_sum_to_depth": bool(np.allclose(lib[nz], depth, rtol=1e-4)),
+              "gene_order_equals_panel": True, "cells_per_target": N_CELLS}
+    if not all(v for k, v in checks.items() if isinstance(v, bool)):
+        raise SystemExit(f"output checks failed: {checks}")
+    n_t = len(targets)
+    avail = np.zeros((n_t, panel_ids.size), dtype=bool)
+    avail[:, pidx] = True
+    meta = {"method": "scSemiProfiler", "arm": "scsemi5" if man["mode"] == "fewshot" else "scsemi",
+            "setting": run["protocol"]["setting"], "dataset": man["dataset"], "mode": man["mode"], "split": man["split"],
+            "input_condition_path": man["condition_npz"], "input_condition_sha256": man["condition_sha256"],
+            "seed": SEED, "run_signature": signature, "upstream_commit": run["protocol"]["upstream_commit"],
+            "protocol": run["protocol"], "representatives": [r["sample_id"] for r in man["representatives"]],
+            "train_donors": man["train_donors"], "n_modeled_genes": len(genes),
+            "unit": "expected_counts (Poisson rates)", "depth_rule": man["depth"]["rule"], "depth": depth,
+            "cell_rule": "1500 per target from the n_rep upstream cells: without replacement if n_rep >= 1500, else "
+                         "whole permutations concatenated to 1500; default_rng([20260927, uint64 LE sha256(target)[:8]]); "
+                         "kept rows sorted (source_row)",
+            "support_readout": "upstream (values <= 10 normalized units zeroed by fast_semi)", "smoke": smoke,
+            "code_migrations": [{"at": m["at"], "transitions": m["transitions"], "to_code_signature": m["to_code_signature"]}
+                                for m in run.get("migrations", [])],
+            "work": str(work)}
+    out.parent.mkdir(parents=True, exist_ok=True)
+    tmp = out.with_name(out.stem + ".tmp.npz")
+    np.savez_compressed(tmp, generated_counts=G, gene_ids=panel_ids, gene_symbols=panel_symbols,
+                        sample_ids=np.asarray(targets), bulk_index=np.repeat(np.arange(n_t, dtype=np.int64), N_CELLS),
+                        cells_per_bulk=np.full(n_t, N_CELLS, dtype=np.int64), output_availability_mask=avail,
+                        source_row=np.concatenate(src_rows), metadata_json=np.asarray(json.dumps(meta)))
+    with np.load(tmp, allow_pickle=False) as chk:   # the scorer opens NPZs with allow_pickle=False
+        for key in chk.files:
+            chk[key]
+    os.replace(tmp, out)
+    receipt = {"output": str(out), "output_sha256": sha(out), "written_utc": datetime.now(timezone.utc).isoformat(),
+               "condition_npz": man["condition_npz"], "condition_sha256": man["condition_sha256"], "seed": SEED,
+               "bulks": n_t, "cells": int(G.shape[0]), "genes": int(panel_ids.size), "modeled_genes": len(genes),
+               "depth": depth, "checks": checks, "per_target": per,
+               "total_target_seconds": float(sum(p["elapsed_seconds"] for p in per)),
+               "median_target_seconds": float(np.median([p["elapsed_seconds"] for p in per])),
+               "run_signature": signature, "code_migrations": meta["code_migrations"],
+               "exporter_sha256": sha(Path(__file__)), "smoke": smoke}
+    rtmp = out.with_name(out.stem + ".log.tmp")
+    rtmp.write_text(json.dumps(receipt, indent=1) + "\n")
+    os.replace(rtmp, out.with_suffix(".log"))
+    print(json.dumps({k: receipt[k] for k in ("output", "bulks", "cells", "modeled_genes", "depth",
+                                              "median_target_seconds")}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,80 @@
+"""Memory-lean, output-identical drop-in for upstream scSemiProfiler.singlecell_process.fast_cellgraph.
+
+Upstream (commit c2aea02) keeps several dense n x n float64/float32 copies of the k-NN graph, materialises an
+n x (k-1) x G gather plus two temporaries of the same size for the neighbour-smoothed features (~10 GB at 15.6k cells,
+above the 16 GiB CPU-unit cap), and finds each cell's neighbours with an O(n^2) Python loop.  This version performs
+the same arithmetic in the same order:
+  adj      = kneighbors_graph(X, k, connectivity, include_self=True).toarray() + float32(diagw) on the diagonal,
+             divided by the (float64) row-sum vector broadcast over the last axis exactly as upstream (adj / adj.sum(1)),
+             selfw = diagonal (float32), diagonal then set to 0; stored densely in obsm['adj'] as upstream
+  neighbors= the column indices of each row's non-zeros in np.where row-major order; vectorised when every row has
+             exactly k-1 of them (always true for a k-NN graph with self), otherwise upstream's loop verbatim
+  neighborx= log(1+X)*selfw[0] + log(1+X[neighbors]).sum(1)*(1-selfw[0])/(k-1), computed in row chunks (a row's
+             value depends only on that row, and numpy's axis-1 sum is per-element, so chunking does not change bits)
+It returns (adata, adj_tensor) like upstream.  tools/verify_lean_cellgraph.py checks bit-identity against upstream
+on real representatives before this is used, and run_scsemi_paired.py records its use in the run signature.
+"""
+from __future__ import annotations
+
+import numpy as np
+import torch
+from sklearn.neighbors import kneighbors_graph
+
+CHUNK = 1024
+
+
+def _upstream_neighbor_loop(xs: np.ndarray, ys: np.ndarray, n: int, maxn: int) -> np.ndarray:
+    neighbors = np.zeros((n, maxn - 1)) - 1
+    for i in range(n):
+        ns = np.zeros(maxn - 1) - 1
+        flag = 0
+        j = 0
+        k = 0
+        while flag != 2 and j < xs.shape[0]:
+            if xs[j] == i:
+                ns[k] = (ys[j])
+                k += 1
+                flag = 1
+            elif flag == 1:
+                flag = 2
+            j += 1
+        neighbors[i] = ns
+    return neighbors.astype(int)
+
+
+def fast_cellgraph_lean(adata, k: int = 15, diagw: float = 1.0):
+    Xd = np.array(adata.X)
+    n = Xd.shape[0]
+    adj = kneighbors_graph(Xd, k, mode='connectivity', include_self=True).toarray()
+    # upstream: diag = identity(n).astype('float32') * diagw ; adj = adj + diag ; adj = adj / adj.sum(axis=1)
+    dval = (np.ones(1, dtype=np.float32) * diagw)[0]
+    idx = np.arange(n)
+    adj[idx, idx] = adj[idx, idx] + dval
+    rs = adj.sum(axis=1)
+    for s in range(0, n, CHUNK):
+        adj[s:s + CHUNK] = adj[s:s + CHUNK] / rs          # broadcast over the last axis, as upstream
+    selfw = adj[idx, idx].copy().astype('float32')
+    adata.obs['selfw'] = selfw
+    adj[idx, idx] = 0
+    adata.obsm['adj'] = adj
+    # upstream: neighboridx = np.where(torch.from_numpy(adj.astype('float32')) != 0)
+    xs_l, ys_l = [], []
+    for s in range(0, n, CHUNK):
+        r, c = np.nonzero(adj[s:s + CHUNK].astype('float32') != 0)
+        xs_l.append(r + s)
+        ys_l.append(c)
+    xs, ys = np.concatenate(xs_l), np.concatenate(ys_l)
+    maxn = k
+    counts = np.bincount(xs, minlength=n)
+    if n and np.all(counts == maxn - 1):
+        neighbors = ys.reshape(n, maxn - 1).astype(int)
+    else:
+        neighbors = _upstream_neighbor_loop(xs, ys, n, maxn)
+    adata.obsm['neighbors'] = neighbors
+    out = np.empty(Xd.shape, dtype=np.result_type(np.log(1 + Xd[:1]) * selfw[0]))
+    w0 = selfw[0]
+    for s in range(0, n, CHUNK):
+        e = min(n, s + CHUNK)
+        out[s:e] = np.log(1 + Xd[s:e]) * w0 + np.log(1 + Xd[neighbors[s:e], :]).sum(axis=1) * (1 - selfw[0]) / (maxn - 1)
+    adata.obsm['neighborx'] = out
+    return adata, torch.from_numpy(adj.astype('float32'))