Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/1e605e8033024686/liu2021_finalize.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Record the post-assembly outputs in data/liu2021/MANIFEST.json (CPU only, small); the Imperial ESKD pattern.
+
+Adds `post_assembly`: cells_full.npz (from cells_full.BUILD.json, re-hashed here), the tools/prepare_dataset.py run
+(PREPARE.json, folds.csv), the sanity comparison (SANITY.json) and the HTO-negative sensitivity summary.
+Nothing else in the manifest is changed.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pandas as pd
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+OUT = TASK / "data/liu2021"
+RUN = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/liu2021_v1_20261002")
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def main() -> int:
+    man = json.loads((OUT / "MANIFEST.json").read_text())
+    build = json.loads((OUT / "cells_full.BUILD.json").read_text())
+    if sha(OUT / "cells_full.npz") != build["sha256"]:
+        raise SystemExit("cells_full.npz differs from its BUILD record")
+    prep = json.loads((OUT / "PREPARE.json").read_text())
+    if prep["features_sha256"] != man["outputs"]["features.npz"]["sha256"]:
+        raise SystemExit("PREPARE.json was made from a different features.npz")
+    for name, rec in man["outputs"].items():
+        if sha(OUT / name) != rec["sha256"]:
+            raise SystemExit(f"{name} changed after assembly")
+    folds = pd.read_csv(OUT / "folds.csv")
+    sanity = json.loads((RUN / "SANITY.json").read_text())
+    man["post_assembly"] = {
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+        "cells_full": {**build, "bytes": (OUT / "cells_full.npz").stat().st_size},
+        "prepare_dataset": {"command": "CUDA_VISIBLE_DEVICES='' python tools/prepare_dataset.py --dataset liu2021 (cxg_corpus env, bounded systemd unit)",
+                            "tool_sha256": sha(TASK / "tools/prepare_dataset.py"),
+                            "PREPARE.json_sha256": sha(OUT / "PREPARE.json"), "folds.csv_sha256": sha(OUT / "folds.csv"),
+                            "fold_sizes": prep["fold_sizes"],
+                            "usable_rows": int((folds.fold >= 0).sum()),
+                            "rows_in_fold_minus1": folds[folds.fold == -1].sample_id.tolist(),
+                            "donors_in_folds": int(folds[folds.fold >= 0].donor_id.nunique()),
+                            "donors_split_across_folds": int((folds[folds.fold >= 0].groupby("donor_id").fold.nunique() > 1).sum())},
+        "sanity_bulk_vs_pseudobulk": {"definition": sanity["definition"],
+                                      **{ds: {k: v for k, v in rec.items() if k != "per_row"} for ds, rec in sanity["datasets"].items()}},
+        "hto_negative_sensitivity": json.loads((RUN / "identity/HTO_NEGATIVE_SENSITIVITY.json").read_text()),
+        "code": {name: {"path": str(p), "sha256": sha(p)} for name, p in [
+            ("full_cells", RUN / "code/liu2021_full_cells.py"), ("findings", RUN / "code/liu2021_findings.py"),
+            ("sanity", RUN / "code/liu2021_sanity.py"), ("hto_sensitivity", RUN / "code/liu2021_hto_sensitivity.py"),
+            ("run_step", RUN / "code/run_step.sh"), ("finalize", Path(__file__).resolve())]},
+    }
+    (OUT / "MANIFEST.json").write_text(json.dumps(man, indent=1, default=str) + "\n")
+    print(json.dumps(man["post_assembly"]["prepare_dataset"], indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/2e9f4baf0e18957c/liu2021_findings.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Study-level findings for the Liu 2021 build (CPU only): bulk material and protocol, sc chemistry, author filtering
+in the Seurat object, cell selection (sorted / HTO doublet / HTO negative), why the corpus copy was not used (with a
+numeric spot-check against CELLxGENE raw counts), gene coverage, bulk depth, pairing.  Writes
+processing/liu2021_v1_20261002/FINDINGS.json."""
+from __future__ import annotations
+
+import json
+import os
+from collections import Counter
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+RUN = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/liu2021_v1_20261002")
+OUT = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/liu2021")
+REF = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/canonical_genes.tsv")
+POS = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/gene_positions.npy")
+CXG_DIR = Path("/home/sj_server_1/gblee/datalake/single-cell-RNA-seq-datasets/PBMC-cells/"
+               "202_B_GSE161918_Time-resolved_Systems_Immunology_Reveals_a_Late_Juncture_Linked_to_Fatal_COVID-1")
+CORPUS = Path("/home/sj_server_1/PBISC/PBISC-data/single-cell-data-block-blood")
+EXPORT = RUN / "rds_export"
+
+
+def text(v) -> np.ndarray:
+    return np.asarray([x.decode() if isinstance(x, bytes) else str(x) for x in v])
+
+
+def main() -> None:
+    soft = pd.read_csv(RUN / "pairing/GSE161918_samples.csv", dtype=str, keep_default_na=False)
+    bulk_gsm = soft[soft.Sample_title.str.contains("bulk", case=False)]
+    sc_gsm = soft[~soft.Sample_title.str.contains("bulk", case=False)]
+    cells = pd.read_parquet(RUN / "pairing/sc_cell_obs.parquet")
+    pairs = pd.read_csv(OUT / "pairs.csv")
+    f = np.load(OUT / "features.npz", allow_pickle=False)
+    folds = pd.read_csv(OUT / "folds.csv")
+    pos = np.load(POS)
+    for c in ("nCount_RNA", "nFeature_RNA", "percent.mito"):
+        cells[c] = cells[c].astype(float)
+
+    # ---------------- bulk material and protocol (GEO)
+    desc = sorted(set(bulk_gsm.Sample_description.str.split("|").str[0]))
+    bulk_material = {
+        "geo_source_name": sorted(set(bulk_gsm.Sample_source_name_ch1)),
+        "geo_unsorted_or_sorted": sorted(set(bulk_gsm["ch_unsorted or sorted t/b cells"])),
+        "geo_molecule": sorted(set(bulk_gsm.Sample_molecule_ch1)), "geo_description": desc,
+        "conclusion": ("PBMC bulk (not whole blood): every one of the 73 bulk GSMs has source 'Peripheral Blood Mononuclear "
+                       "Cells' and 'Unsorted'; 100,000 PBMCs per sample in Trizol, miRNeasy micro, Illumina TruSeq "
+                       "library, STAR, htseq-count 0.9.1 with the UCSC hg19 annotation. The bulk RNA of each sample was "
+                       "also the SNP reference used by demuxlet to assign single cells to subjects.")}
+    # ---------------- sc chemistry
+    first = cells.groupby("Batch").BARCODE.min().to_dict()
+    sc_chem = {"geo_statement": sorted(set(sc_gsm.Sample_extract_protocol_ch1.str.split("|").str[-1].str.extract(
+                   r"(10x 5. Chromium Single Cell Immune Profiling Next GEM v1\.1 chemistry)")[0].dropna())),
+               "geo_processing": sorted(set(x for v in sc_gsm.Sample_data_processing for x in v.split("|")
+                                            if x.startswith(("mapping", "Genome_build", "sample demultiplexing",
+                                                             "secondary analysis")))),
+               "first_sorted_barcode_by_batch": first,
+               "barcode_suffixes": sorted({b.rsplit("-", 1)[-1] for b in cells.BARCODE.unique()}),
+               "conclusion": ("10x 5' Next GEM v1.1 CITE-seq (GEX + 192 ADT + HTO + TCR); Cell Ranger 3.1.0 with the hg19-1.2.0 "
+                              "reference (32,738 genes; the Seurat RNA rownames equal this table, see reference_crosswalk). "
+                              "Only the RNA counts are used.")}
+    # ---------------- author filtering present in the object
+    sel = cells[cells.selected]
+    author = {"object_cells": int(len(cells)), "object_min_nFeature_RNA": int(cells.nFeature_RNA.min()),
+              "object_max_nFeature_RNA": int(cells.nFeature_RNA.max()), "object_min_nCount_RNA": float(cells.nCount_RNA.min()),
+              "object_max_percent_mito": float(100 * cells["percent.mito"].max()),
+              "selected_cells": int(len(sel)), "selected_min_nFeature_RNA": int(sel.nFeature_RNA.min()),
+              "selected_min_nCount_RNA": float(sel.nCount_RNA.min()), "selected_max_percent_mito": float(100 * sel["percent.mito"].max()),
+              "selected_failing_conservative_rule": {"genes_lt_200": int((sel.nFeature_RNA < 200).sum()),
+                                                     "umis_lt_500": int((sel.nCount_RNA < 500).sum()),
+                                                     "mito_gt_20pct": int((100 * sel["percent.mito"] > 20).sum())},
+              "author_cluster_doublets_in_selected": {c: int(v) for c, v in sel.WCTcoursecelltype.value_counts().items() if c in ("Dblt", "dblt")},
+              "conclusion": ("The author object is already filtered (every cell has >= 200 genes, author percent.mito is a fraction, "
+                             "max ~0.3); it still holds HTO doublets/negatives (all demuxlet singlets) and the sorted fractions. "
+                             "The ImMicro rule (>=200 genes, >=500 UMIs, <=20 % mito) is applied on top. Author cluster-level "
+                             "'Dblt' cells are not an HTO call and are kept (counted here).")}
+    # ---------------- cell selection
+    uns = cells[cells.Sorted == "N"]
+    b23 = uns[uns.Batch.isin(["B2", "B3"])]
+    comp = pd.crosstab(b23.WCTcoursecelltype, b23["HTO_classification.global"], normalize="columns")
+    tv = float(0.5 * (comp["Singlet"] - comp["Negative"]).abs().sum())
+    diff = (comp["Negative"] - comp["Singlet"]).sort_values()
+    selection = {
+        "by_batchsort_and_hto": pd.crosstab(cells.BatchSort, cells["HTO_classification.global"]).to_dict(),
+        "why_unsorted_only": ("The bulk is unsorted PBMC. Batch 1 lanes pool FACS-sorted B, T, CD14+ monocyte and CD14- innate "
+                              "cells with unsorted PBMC 1:1:1:1:1 (sorted and unsorted fractions carry different hashtags), and "
+                              "batches 2-3 have separate lanes of sorted non-naive T and B cells. Sorted cells would distort the "
+                              "composition, so only Sorted == 'N' cells are used. Consequence: batch-1 samples keep only ~120-490 "
+                              "cells each."),
+        "hto_negative_composition_b2_b3_unsorted": {
+            "total_variation_singlet_vs_negative": tv,
+            "cell_types_more_frequent_among_negatives": diff.tail(5).round(4).to_dict(),
+            "cell_types_less_frequent_among_negatives": diff.head(5).round(4).to_dict(),
+            "note": ("HTO 'Negative' cells concentrate in weakly stained pools (B2 HTO3, B3 HTO5: 30-70 % of a sample). "
+                     "They are dropped per the task rule (their timepoint was assigned by the authors from the max, "
+                     "below-threshold hashtag); this total-variation distance measures how much their author cell-type "
+                     "mix differs from the singlets'.")},
+        "paired_rows_dropped": {"sorted_cells": int(pairs.n_sorted_dropped.sum()), "hto_doublets": int(pairs.n_hto_doublet_dropped.sum()),
+                                "hto_negatives": int(pairs.n_hto_negative_dropped.sum()),
+                                "hto_negative_fraction_of_unsorted_max": float((pairs.n_hto_negative_dropped / pairs.n_unsorted).max()),
+                                "rows_with_negative_fraction_gt_0.3": int(((pairs.n_hto_negative_dropped / pairs.n_unsorted) > 0.3).sum())}}
+    # ---------------- why the corpus / CELLxGENE copy was not used, plus a numeric spot-check of our counts
+    exp_ids = json.loads((RUN / "singlecell/feature_axis.json").read_text())["ids"]
+    p_arr = np.fromfile(EXPORT / "rna_counts_p.int32", dtype="<i4").astype(np.int64)
+    i_arr = np.memmap(EXPORT / "rna_counts_i.int32", dtype="<i4", mode="r")
+    x_arr = np.memmap(EXPORT / "rna_counts_x.int32", dtype="<i4", mode="r")
+    by_name = pd.Series(cells.col_index.to_numpy(), index=cells.cell.to_numpy())
+    cxg, spot = {}, []
+    rng = np.random.default_rng(20261002)
+    for h5 in sorted(CXG_DIR.glob("*.h5ad")):
+        with h5py.File(h5, "r") as h:
+            idx = text(h["obs/_index"][:])
+            var = text(h["raw/var/_index"][:])
+            names = set(by_name.index)
+            inobj = np.fromiter((x in names for x in idx), dtype=bool, count=len(idx))
+            m = cells.set_index("cell").reindex(idx[inobj])
+            cxg[h5.name] = {"cells": int(len(idx)), "genes": int(len(var)), "cells_in_author_object": int(inobj.sum()),
+                            "of_which_sorted": int((m.Sorted == "Y").sum()), "of_which_hto_not_singlet": int((m["HTO_classification.global"] != "Singlet").sum()),
+                            "obs_has_sorted_or_hto_columns": any(k in h["obs"] for k in ("Sorted", "BatchSort", "HTO_classification.global"))}
+            ip = h["raw/X/indptr"]
+            vpos = {g: k for k, g in enumerate(var)}
+            fg = h["raw/var/feature_name"]
+            fname = (np.asarray(text(fg["categories"][:]))[fg["codes"][:]] if isinstance(fg, h5py.Group) else text(fg[:]))
+            exp_sym = json.loads((RUN / "singlecell/feature_axis.json").read_text())["symbols"]
+            for k in rng.choice(np.flatnonzero(inobj), size=4, replace=False):
+                a, b = int(ip[k]), int(ip[k + 1])
+                cv = h["raw/X/data"][a:b]; ci = h["raw/X/indices"][a:b]
+                col = int(by_name[idx[k]])
+                oi = np.asarray(i_arr[p_arr[col]:p_arr[col + 1]]); ox = np.asarray(x_arr[p_arr[col]:p_arr[col + 1]])
+                ours = {exp_ids[g]: int(v) for g, v in zip(oi, ox)}
+                theirs = {var[g]: float(v) for g, v in zip(ci, cv)}
+                shared = [g for g in ours if g in vpos]
+                # genes CELLxGENE counts under an Ensembl ID that is not in the hg19-1.2.0 table: compare by symbol
+                ours_by_sym = {exp_sym[g]: int(v) for g, v in zip(oi, ox)}
+                relabel = [{"cxg_id": g, "cxg_feature_name": str(fname[vpos[g]]), "cxg_count": theirs[g],
+                            "our_count_same_symbol": ours_by_sym.get(str(fname[vpos[g]]))}
+                           for g in theirs if g not in ours]
+                spot.append({"file": h5.name, "cell": idx[k], "our_umis": int(ox.sum()), "our_genes_in_cxg_var": len(shared),
+                             "equal_on_shared_ids": all(theirs.get(g, 0.0) == ours[g] for g in shared),
+                             "cxg_ids_not_in_hg19_table": relabel,
+                             "equal_after_symbol_match": all(theirs.get(g, 0.0) == ours[g] for g in shared) and
+                                                         all(r["cxg_count"] == r["our_count_same_symbol"] for r in relabel),
+                             "cxg_umis": float(cv.sum()), "our_umis_on_cxg_genes": int(sum(ours[g] for g in shared))})
+    corpus = {}
+    for pq in sorted((CORPUS / "metadata/obs_sc.parquet").glob("202_B_GSE161918*.parquet")):
+        o = pd.read_parquet(pq, columns=["cell_id", "donor_id", "timepoint", "qc_status"])
+        corpus[pq.name] = {"rows": int(len(o)), "has_barcode_column": False, "qc_status": o.qc_status.value_counts().to_dict(),
+                           "donor_timepoints": int(o[["donor_id", "timepoint"]].drop_duplicates().shape[0])}
+    source = {"used": "author Seurat object GSE161918_AllBatches_SeuratObj.rds.gz (RNA counts slot), exported unchanged in R",
+              "cellxgene_h5ad": cxg, "corpus_obs": corpus, "spot_check_cellxgene_raw_vs_our_counts": spot,
+              "conclusion": ("Not the corpus copy: the CELLxGENE files it derives from hold 372,081 of the object's 411,902 cells "
+                             "on a 30,000-gene Ensembl axis, include sorted-fraction cells and HTO doublets/negatives, but carry "
+                             "no Sorted / HTO-classification columns, so the unsorted HTO-singlet subset needed to match an "
+                             "unsorted PBMC bulk cannot be selected there; the corpus parquet has no barcodes and its own QC. "
+                             "The spot-check (8 random cells) compares the exported counts with CELLxGENE raw/X: equal on every "
+                             "shared Ensembl ID, and the only extra CELLxGENE entries are genes it labels with a newer "
+                             "Ensembl ID (e.g. SOD2 ENSG00000291237 vs hg19 ENSG00000112096), equal when matched by symbol; "
+                             "CELLxGENE drops the remaining hg19 genes (30,000 kept), which is why our cells have more UMIs.")}
+    # ---------------- gene coverage and bulk depth
+    cg = pd.read_csv(REF, sep="\t", dtype=str)
+    rep = json.loads((RUN / "bulk/GSE161918_htseq/REPORT.json").read_text())
+    bv, sv = f["bulk_valid"][0], f["sc_valid"][0]
+    src = np.load(RUN / "bulk/bulk_source_counts.npz")
+    tot = src["counts"].sum(1)
+    paired_cols = set(pairs.bulk_count_column)
+    ptot = np.asarray([t for c, t in zip(src["sample_ids"], tot) if c in paired_cols])
+    coverage = {"bulk_canonical_measured": int(bv.sum()), "sc_canonical_measured": int(sv.sum()),
+                "pair_valid": int((bv & sv).sum()), "panel6k_bulk": int(bv[pos].sum()), "panel6k_sc": int(sv[pos].sum()),
+                "panel6k_both": int((bv & sv)[pos].sum()),
+                "bulk_mapping_summary": rep["source_gene_mapping_summary"],
+                "bulk_duplicate_target_groups_summed": rep["duplicate_target_groups_summed_counts"],
+                "bulk_has_ribosomal_and_mito_genes": bool(np.all(bv[cg.gene_symbol.str.startswith(("RPL", "RPS")).to_numpy() & sv])),
+                "note": "Unlike Giroux, the author bulk table keeps ribosomal-protein and mitochondrial genes."}
+    depth = {"assigned_reads_paired_columns": {"min": float(ptot.min()), "median": float(np.median(ptot)), "max": float(ptot.max())},
+             "by_table": {t: float(np.median([v for c, v in zip(src["sample_ids"], tot) if c in set(g.bulk_column)]))
+                          for t, g in pd.read_csv(RUN / "pairing/bulk_count_columns.csv").groupby("table_file")}}
+    usable = folds.fold >= 0
+    findings = {
+        "bulk_material_and_protocol": bulk_material, "sc_chemistry": sc_chem, "author_filtering": author,
+        "cell_selection": selection, "sc_source_choice": source, "gene_coverage": coverage, "bulk_depth": depth,
+        "pairing": json.loads((RUN / "pairing/PAIRING_SUMMARY.json").read_text()),
+        "identity": json.loads((OUT / "MANIFEST.json").read_text())["checks"],
+        "usable_rows": {"rows": int(len(folds)), "usable": int(usable.sum()),
+                        "usable_by_group": folds[usable].group.value_counts().to_dict(),
+                        "usable_donors_by_group": folds[usable].drop_duplicates("donor_id").group.value_counts().to_dict(),
+                        "usable_by_timepoint": dict(Counter(f["timepoints"][usable.to_numpy()].astype(str))),
+                        "excluded": folds[~usable].sample_id.tolist()},
+        "sanity": json.loads((RUN / "SANITY.json").read_text()) if (RUN / "SANITY.json").exists() else None,
+        "hto_negative_sensitivity": (json.loads((RUN / "identity/HTO_NEGATIVE_SENSITIVITY.json").read_text())
+                                     if (RUN / "identity/HTO_NEGATIVE_SENSITIVITY.json").exists() else None),
+        "cells_full": json.loads((OUT / "cells_full.BUILD.json").read_text()) if (OUT / "cells_full.BUILD.json").exists() else None,
+    }
+    (RUN / "FINDINGS.json").write_text(json.dumps(findings, indent=1, default=str) + "\n")
+    print(json.dumps({"spot": spot, "cxg": cxg, "selection_tv": tv, "coverage": {k: v for k, v in coverage.items() if k != "bulk_mapping_summary"},
+                      "depth": depth, "author": author}, indent=1, default=str))
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/8a4485ba51f51c7e/liu2021_hto_sensitivity.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Sensitivity of the HTO-negative drop (CPU only; informational, changes no output file of the dataset).
+
+For every paired row with HTO-negative unsorted cells: pseudobulks of the author's unsorted cells that pass the same
+cell rule (>= 200 genes, >= 500 UMIs, <= 20 % mito, from the author nFeature/nCount/percent.mito, which equal the
+bundle metrics) for (a) HTO singlets (= the dataset), (b) HTO negatives, (c) singlets + negatives.  Each is compared
+with (i) its own bulk and (ii) the subject's other paired bulks (other timepoints), by Pearson r of log1p CPM over
+genes whose hg19 10x symbol is a row of the author bulk table (CPM over those genes in both assays).
+Writes identity/hto_negative_sensitivity.csv and identity/HTO_NEGATIVE_SENSITIVITY.json.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+RUN = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/liu2021_v1_20261002")
+EXPORT = RUN / "rds_export"
+
+
+def lcpm(v: np.ndarray) -> np.ndarray:
+    return np.log1p(v / v.sum() * 1e6)
+
+
+def main() -> None:
+    pairs = pd.read_csv(RUN / "pairing/pairs_primary.csv", dtype=str, keep_default_na=False)
+    cells = pd.read_parquet(RUN / "pairing/sc_cell_obs.parquet")
+    for c in ("nCount_RNA", "nFeature_RNA", "percent.mito"):
+        cells[c] = cells[c].astype(float)
+    cells["cellpass"] = (cells.nFeature_RNA >= 200) & (cells.nCount_RNA >= 500) & (100 * cells["percent.mito"] <= 20)
+    sym = json.loads((RUN / "singlecell/feature_axis.json").read_text())["symbols"]
+    src = np.load(RUN / "bulk/bulk_source_counts.npz")
+    bsym = list(src["gene_ids"])
+    bpos = {s: k for k, s in enumerate(bsym)}
+    # 10x symbols that occur once in the 10x table and are bulk rows
+    counts = pd.Series(sym).value_counts()
+    sc_idx = np.asarray([k for k, s in enumerate(sym) if counts[s] == 1 and s in bpos])
+    b_idx = np.asarray([bpos[sym[k]] for k in sc_idx])
+    bcols = {c: j for j, c in enumerate(src["sample_ids"])}
+    B = src["counts"][:, b_idx]
+    p = np.fromfile(EXPORT / "rna_counts_p.int32", dtype="<i4").astype(np.int64)
+    ind = np.memmap(EXPORT / "rna_counts_i.int32", dtype="<i4", mode="r")
+    val = np.memmap(EXPORT / "rna_counts_x.int32", dtype="<i4", mode="r")
+
+    def pseudobulk(col_index: np.ndarray) -> np.ndarray:
+        if len(col_index) == 0:
+            return np.zeros(len(sc_idx))
+        starts, stops = p[col_index], p[col_index + 1]
+        g = np.concatenate([np.arange(a, b) for a, b in zip(starts, stops)])
+        ip = np.concatenate([[0], np.cumsum(stops - starts)])
+        M = sp.csr_matrix((np.asarray(val[g], dtype=np.float64), np.asarray(ind[g]), ip), shape=(len(col_index), len(sym)))
+        return np.asarray(M[:, sc_idx].sum(0)).ravel()
+
+    rows = []
+    for _, r in pairs.iterrows():
+        c = cells[(cells.sample_id == r.sc_sample) & (cells.Sorted == "N") & cells.cellpass]
+        hto = c["HTO_classification.global"]
+        sets = {"singlet": c[hto == "Singlet"].col_index.to_numpy(np.int64),
+                "negative": c[hto == "Negative"].col_index.to_numpy(np.int64)}
+        sets["singlet_plus_negative"] = np.concatenate([sets["singlet"], sets["negative"]])
+        own = B[bcols[r.bulk_column]]
+        others = [x for x in pairs[(pairs.Subject == r.Subject) & (pairs.bulk_column != r.bulk_column)].bulk_column]
+        rec = {"sample_id": r.sample_id, "sc_sample": r.sc_sample, "batch": r.Batch, "hashtag": r.hashtags,
+               "n_singlet_pass": len(sets["singlet"]), "n_negative_pass": len(sets["negative"]),
+               "subject_other_timepoints": len(others)}
+        for name, cols in sets.items():
+            if len(cols) < 50:
+                continue
+            pb = pseudobulk(cols)
+            rec[f"r_own_{name}"] = float(np.corrcoef(lcpm(own), lcpm(pb))[0, 1])
+            if others:
+                rec[f"r_best_other_timepoint_{name}"] = max(float(np.corrcoef(lcpm(B[bcols[o]]), lcpm(pb))[0, 1]) for o in others)
+        rows.append(rec)
+    t = pd.DataFrame(rows)
+    t["negative_fraction"] = t.n_negative_pass / (t.n_singlet_pass + t.n_negative_pass)
+    t.to_csv(RUN / "identity/hto_negative_sensitivity.csv", index=False)
+    h = t[t.n_negative_pass >= 50]
+    multi = h[h.subject_other_timepoints > 0]
+    summ = {"genes": int(len(sc_idx)),
+            "rows_with_>=50_negative_cells": int(len(h)),
+            "median_negative_fraction_those_rows": float(h.negative_fraction.median()),
+            "r_own_singlet_median": float(h.r_own_singlet.median()),
+            "r_own_negative_median": float(h.r_own_negative.median()),
+            "r_own_singlet_plus_negative_median": float(h.r_own_singlet_plus_negative.median()),
+            "rows_where_adding_negatives_raises_r_own": int((h.r_own_singlet_plus_negative > h.r_own_singlet).sum()),
+            "negatives_own_timepoint_beats_best_other_timepoint": f"{int((multi.r_own_negative > multi.r_best_other_timepoint_negative).sum())}/{len(multi)}",
+            "singlets_own_timepoint_beats_best_other_timepoint": f"{int((multi.r_own_singlet > multi.r_best_other_timepoint_singlet).sum())}/{len(multi)}",
+            "note": ("r over hg19 symbols shared by the 10x table (unique) and the bulk table; informational only - the "
+                     "dataset keeps the task rule (HTO singlets only)")}
+    (RUN / "identity/HTO_NEGATIVE_SENSITIVITY.json").write_text(json.dumps(summ, indent=1) + "\n")
+    print(json.dumps(summ, indent=1))
+    print(h.round(4).to_string())
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261002T124820Z-crosscohort-liu-default/diffusion/dataset/server_1/dependency/981b08078aab70e8/liu2021_full_cells.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""cells_full.npz for liu2021: tools/build_full_cells.py semantics with bounded memory (CPU only).
+
+Uses build_full_cells.read_library (the tool's own reader) for every library and applies the tool's fail-closed
+checks: cells_obs rows == cells_panel6k rows; cells sorted by dataset row; on every row the panel columns equal
+cells_panel6k exactly and the full-axis sums equal features.npz pseudo_raw_sum.  Rows are streamed through disk
+memmaps (one library = one row here), so peak memory is one library instead of three copies of the whole matrix.
+Output keys, dtypes and cells_full.BUILD.json fields are those of build_full_cells.py.
+"""
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+TOOL = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/tools/build_full_cells.py")
+RUN = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/liu2021_v1_20261002")
+DS = "liu2021"
+spec = importlib.util.spec_from_file_location("build_full_cells", TOOL)
+BF = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(BF)
+BF.LIBRARY_ROOT[DS] = RUN / "singlecell"
+
+
+def main() -> int:
+    d = BF.TASK / "data" / DS
+    obs = pd.read_parquet(d / "cells_obs.parquet")
+    panel = np.load(d / "cells_panel6k.npz", allow_pickle=False)
+    feat = np.load(d / "features.npz", allow_pickle=False)
+    positions = np.load(BF.POSITIONS).astype(np.int64)
+    if len(obs) != int(panel["shape"][0]):
+        raise SystemExit("cells_obs rows differ from cells_panel6k rows")
+    rs = panel["row_sample"].astype(np.int64)
+    if bool((np.diff(rs) < 0).any()):
+        raise SystemExit("cells are not sorted by dataset row")
+    if not np.array_equal(rs, obs.row_sample.to_numpy(np.int64)):
+        raise SystemExit("cells_obs row_sample differs from cells_panel6k row_sample")
+    P = sp.csr_matrix((panel["data"], panel["indices"], panel["indptr"]), shape=tuple(panel["shape"]))
+    want = np.nan_to_num(feat["pseudo_raw_sum"].astype(np.float64), nan=0.0)
+    n_rows = int(rs.max()) + 1
+    bounds = np.searchsorted(rs, np.arange(n_rows + 1))
+    root = BF.LIBRARY_ROOT[DS]
+    parts, total_nnz = [], 0
+    tmp = RUN / "full_cells_tmp"
+    tmp.mkdir(exist_ok=True)
+    bad_panel = bad_sum = 0
+    for r in range(n_rows):
+        a, b = int(bounds[r]), int(bounds[r + 1])
+        sub = obs.iloc[a:b]
+        libs = sub.library_id.unique()
+        if len(libs) != 1:
+            raise SystemExit(f"row {r}: expected one library, found {list(libs)}")
+        Xr = BF.read_library(root / str(libs[0]) / "canonical.h5ad", sub["barcode"].astype(str).to_numpy())
+        bad_panel += int((Xr[:, positions] != P[a:b]).nnz)
+        bad_sum += int(not np.array_equal(np.asarray(Xr.sum(axis=0, dtype=np.float64)).ravel(), want[r]))
+        np.save(tmp / f"{r:03d}_data.npy", Xr.data.astype(np.int32))
+        np.save(tmp / f"{r:03d}_indices.npy", Xr.indices.astype(np.int32))
+        np.save(tmp / f"{r:03d}_indptr.npy", Xr.indptr.astype(np.int64))
+        parts.append((Xr.shape[0], Xr.nnz))
+        total_nnz += Xr.nnz
+        print(f"{libs[0]}: {Xr.shape[0]} cells", flush=True)
+        del Xr
+    if bad_panel:
+        raise SystemExit(f"full-axis cells differ from cells_panel6k on the panel columns ({bad_panel} entries)")
+    if bad_sum:
+        raise SystemExit(f"per-row full-axis sums differ from pseudo_raw_sum for {bad_sum} rows")
+    n_cells = sum(c for c, _ in parts)
+    if n_cells != len(obs):
+        raise SystemExit("assembled cell count differs")
+    data = np.lib.format.open_memmap(tmp / "all_data.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indices = np.lib.format.open_memmap(tmp / "all_indices.npy", mode="w+", dtype=np.int32, shape=(total_nnz,))
+    indptr = np.empty(n_cells + 1, dtype=np.int64)
+    indptr[0] = 0
+    at = cell_at = 0
+    for r in range(n_rows):
+        dd = np.load(tmp / f"{r:03d}_data.npy"); ix = np.load(tmp / f"{r:03d}_indices.npy")
+        ip = np.load(tmp / f"{r:03d}_indptr.npy")
+        data[at:at + len(dd)] = dd
+        indices[at:at + len(dd)] = ix
+        indptr[cell_at + 1:cell_at + len(ip)] = ip[1:] + at
+        at += len(dd); cell_at += len(ip) - 1
+    if at != total_nnz or cell_at != n_cells or indptr[-1] != total_nnz or bool((np.diff(indptr) < 0).any()):
+        raise SystemExit("assembly size / indptr")
+    data.flush(); indices.flush()
+    out = d / "cells_full.npz"
+    part = d / "cells_full.npz.partial"
+    with open(part, "wb") as h:
+        np.savez(h, data=data, indices=indices, indptr=indptr, shape=np.array([n_cells, 20097], dtype=np.int64),
+                 row_sample=rs.astype(np.int32))
+    os.replace(part, out)
+    del data, indices
+    # re-open the written file and re-run the row checks on it (fail-closed on the artifact itself)
+    z = np.load(out, allow_pickle=False, mmap_mode=None)
+    for k, dt in (("data", np.int32), ("indices", np.int32), ("indptr", np.int64), ("shape", np.int64), ("row_sample", np.int32)):
+        if z[k].dtype != dt:
+            raise SystemExit(f"{k} dtype {z[k].dtype}")
+    X = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=tuple(z["shape"]))
+    for r in range(n_rows):
+        a, b = int(bounds[r]), int(bounds[r + 1])
+        Xr = X[a:b]
+        if (Xr[:, positions] != P[a:b]).nnz or not np.array_equal(np.asarray(Xr.sum(axis=0, dtype=np.float64)).ravel(), want[r]):
+            raise SystemExit(f"row {r}: written cells_full.npz fails the checks")
+    del X, z
+    for q in tmp.iterdir():
+        q.unlink()
+    tmp.rmdir()
+    info = {"dataset": DS, "n_cells": int(n_cells), "nnz": int(total_nnz), "sha256": BF.sha(out),
+            "checks": {"panel_columns_equal_cells_panel6k": True, "row_sums_equal_pseudo_raw_sum": True},
+            "builder": "processing/liu2021_v1_20261002/code/liu2021_full_cells.py (build_full_cells.read_library, same checks, streamed; re-verified on the written file)"}
+    (d / "cells_full.BUILD.json").write_text(json.dumps(info, indent=1))
+    print(json.dumps(info))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())