Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261015T131236Z-corpus-five-marker-codetection/diffusion/dataset/server_1/model8/plans/corpus_macrophage_markers_20261015/candidate_marker_counts.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca6ad59fb6d2d291e77ea360ad81a1f53a697d828c8a07408c3ab2663267cd5f
+size 750374

paper-releases/pbisc-diffusion/updates/20261015T131236Z-corpus-five-marker-codetection/diffusion/dataset/server_1/model8/plans/corpus_macrophage_markers_20261015/check_candidates.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""Five-marker raw-count audit in exactly defined training-source candidates.
+
+CPU only. Metadata selection is followed by a small-column sparse extraction;
+no full expression matrix or corpus-wide expression search is constructed.
+"""
+from __future__ import annotations
+import argparse
+from collections import defaultdict
+import hashlib
+import json
+from pathlib import Path
+import time
+
+import numpy as np
+import pandas as pd
+import pyarrow.parquet as pq
+import zarr
+
+ROOT = Path(__file__).resolve().parent
+M7 = Path('/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data')
+E2 = M7 / 'e2_full_source'
+BLOCK = Path('/home/sj_server_1/PBISC/PBISC-data/single-cell-data-block-blood')
+KEY = ['dataset_id', 'donor_id', 'sample_id']
+LABELS = {'C1Q+ CD16 monocyte', 'CD16+_Monocyte_C1QAhi', 'flagged_intermediate_monocyte_C1QAhi'}
+LABEL_COLS = ['label_original', 'label_original_raw_rebuilt'] + [f'source_celltype_l{i}' for i in range(1, 5)]
+GENES = ['C1QA', 'CD163', 'CD68', 'WARS1', 'LGALS3']
+IDS = ['ENSG00000173372', 'ENSG00000177575', 'ENSG00000129226', 'ENSG00000140105', 'ENSG00000131981']
+COLS = np.array([291, 11665, 15192, 13485, 13194])
+zarr.config.set({'async.concurrency': 2, 'threading.max_workers': 2})
+
+def sha(p):
+    h = hashlib.sha256()
+    with Path(p).open('rb') as f:
+        for b in iter(lambda: f.read(1 << 20), b''): h.update(b)
+    return h.hexdigest()
+
+def receipt(p):
+    p = Path(p)
+    return {'path': str(p), 'bytes': p.stat().st_size, 'sha256': sha(p)}
+
+def write_json(p, x):
+    Path(p).write_text(json.dumps(x, indent=2) + '\n')
+
+def prepare():
+    records, selected, shards = [], [], []
+    sp = M7 / 'e2_full_index/metadata/sample_index.parquet'
+    si = pd.read_parquet(sp)
+    records.append(receipt(sp))
+    for k in KEY: si[k] = si[k].astype(str)
+    assert not si.duplicated(KEY).any()
+    files = [p for p in sorted((E2 / 'metadata/obs_sc.parquet').glob('*.parquet'))
+             if p.name[:4] in ['006_', '009_', '065_', '200_'] and not p.name.endswith('__strict_overlay.parquet')]
+    assert len(files) == 89
+    total_rows = 0
+    for i, ep in enumerate(files):
+        bp = BLOCK / 'metadata/obs_sc.parquet' / ep.name
+        eq, bq = pq.ParquetFile(ep), pq.ParquetFile(bp)
+        assert eq.metadata.num_rows == bq.metadata.num_rows
+        cols = [c for c in LABEL_COLS if c in bq.schema.names]
+        bi = iter(bq.iter_batches(batch_size=32768, columns=['source_row_index'] + cols, use_threads=False))
+        offset = 0
+        local = []
+        for eb in eq.iter_batches(batch_size=32768, columns=KEY + ['source_row_index'], use_threads=False):
+            e, b = eb.to_pandas(), next(bi).to_pandas()
+            assert len(e) == len(b) and np.array_equal(e.source_row_index, b.source_row_index)
+            hits = b[cols].isin(LABELS)
+            keep = hits.any(axis=1).to_numpy()
+            if keep.any():
+                v = e.loc[keep].copy()
+                for k in KEY: v[k] = v[k].astype(str)
+                v['shard_row'] = np.flatnonzero(keep) + offset
+                v['source_label'] = b.loc[keep, cols].where(hits.loc[keep]).bfill(axis=1).iloc[:, 0].to_numpy()
+                v = v.merge(si[KEY + ['split', 'sample_key']], on=KEY, how='left', validate='many_to_one')
+                assert v.split.notna().all()
+                v = v[v.split == 'train'].copy()
+                v['shard_id'] = ep.stem
+                v['flagged'] = v.source_label.str.startswith('flagged_')
+                local.append(v)
+            offset += len(e)
+        assert next(bi, None) is None and offset == eq.metadata.num_rows
+        total_rows += offset
+        if local: selected.extend(local)
+        records.extend([receipt(ep), receipt(bp)])
+        shards.append({'shard_id': ep.stem, 'rows': offset})
+        print(f'metadata {i+1}/{len(files)}', flush=True)
+    v = pd.concat(selected, ignore_index=True)
+    assert len(v) == 34122 and int(v.flagged.sum()) == 903
+    assert not v.duplicated(['shard_id', 'shard_row']).any()
+    assert total_rows == 20609391
+    expected = {'006': 2726, '009': 3058, '065': 25268, '200': 2167}
+    assert v[~v.flagged].groupby(v.dataset_id.str[:3]).size().to_dict() == expected
+    v.to_parquet(ROOT / 'selected_training_candidates.parquet', index=False)
+    plans = []
+    for sid, d in v.groupby('shard_id', sort=True):
+        zp = BLOCK / 'counts/sc_counts' / (sid + '.zarr')
+        g = zarr.open_group(str(zp), mode='r')
+        for f in sorted(zp.glob('**/zarr.json')): records.append(receipt(f))
+        attrs = dict(g.attrs)
+        assert attrs['shape'][0] == next(s['rows'] for s in shards if s['shard_id'] == sid)
+        mask = np.asarray(g['measurement_mask'][:])[COLS]
+        assert mask.shape == (5,) and mask.sum() == 5
+        ptr = np.asarray(g['indptr'][:], dtype=np.int64)
+        rows = d.shard_row.to_numpy()
+        chunk = g['indices'].chunks[0]
+        assert chunk == g['data'].chunks[0] == 1000000
+        chunks = sorted(set(c for r in rows for c in range(int(ptr[r]) // chunk, (int(ptr[r+1]) - 1) // chunk + 1)))
+        paths = [zp / a / 'c' / str(c) for c in chunks for a in ['indices', 'data']]
+        comp = sum(p.stat().st_size for p in paths if p.exists())
+        plans.append({'shard_id': sid, 'candidate_cells': len(d), 'chunks': chunks,
+                      'compressed_bytes_to_read': comp, 'decompressed_bytes_upper_bound': len(chunks) * chunk * 12,
+                      'candidate_nnz': int((ptr[rows+1] - ptr[rows]).sum()),
+                      'measured': mask.tolist(), 'count_source': attrs['source_count_matrix']})
+    write_json(ROOT / 'extraction_plan.json', {'candidate_cells': len(v), 'unflagged': int((~v.flagged).sum()),
+                  'flagged': int(v.flagged.sum()), 'source_rows_metadata_only': total_rows,
+                  'compressed_bytes_to_read': sum(p['compressed_bytes_to_read'] for p in plans),
+                  'decompressed_bytes_upper_bound': sum(p['decompressed_bytes_upper_bound'] for p in plans),
+                  'plans': plans, 'metadata_sources': records})
+    print(json.dumps({'candidate_cells': len(v), 'compressed_GiB': sum(p['compressed_bytes_to_read'] for p in plans)/2**30,
+                      'decoded_GiB': sum(p['decompressed_bytes_upper_bound'] for p in plans)/2**30}), flush=True)
+
+def extract():
+    plan = json.loads((ROOT / 'extraction_plan.json').read_text())
+    v = pd.read_parquet(ROOT / 'selected_training_candidates.parquet')
+    out = np.zeros((len(v), 5), dtype=np.int64)
+    row_sum = np.zeros(len(v), dtype=np.int64)
+    chunk_receipts, checks = [], []
+    for i, pp in enumerate(plan['plans']):
+        sid = pp['shard_id']
+        d = v[v.shard_id == sid].sort_values('shard_row')
+        zp = BLOCK / 'counts/sc_counts' / (sid + '.zarr')
+        g = zarr.open_group(str(zp), mode='r')
+        assert np.array_equal(np.asarray(g['measurement_mask'][:])[COLS], np.ones(5))
+        ptr = np.asarray(g['indptr'][:], dtype=np.int64)
+        segs = defaultdict(list)
+        size = 1000000
+        for oi, r in zip(d.index, d.shard_row):
+            start, end = int(ptr[r]), int(ptr[r+1])
+            while start < end:
+                c = start // size
+                stop = min(end, (c+1)*size)
+                segs[c].append((int(oi), start-c*size, stop-c*size))
+                start = stop
+        assert sorted(segs) == pp['chunks']
+        source_nnz = 0
+        for c, sections in sorted(segs.items()):
+            start, end = c*size, min((c+1)*size, g['indices'].shape[0])
+            ids = np.asarray(g['indices'][start:end], dtype=np.int32)
+            values = np.asarray(g['data'][start:end], dtype=np.int64)
+            assert len(ids) == len(values) and (values >= 0).all()
+            for oi, a, b in sections:
+                ix, vals = ids[a:b], values[a:b]
+                source_nnz += b-a
+                row_sum[oi] += vals.sum()
+                for j, col in enumerate(COLS): out[oi, j] += vals[ix == col].sum()
+            for arr in ['indices', 'data']:
+                fp = zp / arr / 'c' / str(c)
+                if fp.exists(): chunk_receipts.append(receipt(fp))
+        assert source_nnz == pp['candidate_nnz']
+        checks.append({'shard_id': sid, 'candidate_cells': len(d), 'selected_nnz': source_nnz,
+                       'unique_chunks': len(segs), 'all_markers_measured': True})
+        print(f'expression {i+1}/{len(plan["plans"])} {sid[:3]} n={len(d)}', flush=True)
+    assert (out >= 0).all() and (row_sum > 0).all()
+    for i, gene in enumerate(GENES): v[gene] = out[:, i]
+    v['total_counts_20097'] = row_sum
+    v['markers_detected'] = (out > 0).sum(axis=1)
+    v['all_five_detected'] = (out > 0).all(axis=1)
+    v['c1qa_plus_at_least_three_others'] = (out[:, 0] > 0) & ((out[:, 1:] > 0).sum(axis=1) >= 3)
+    v.to_parquet(ROOT / 'candidate_marker_counts.parquet', index=False)
+    summarize(v, plan, checks, chunk_receipts)
+
+def summarize(v, plan, checks, chunk_receipts):
+    groups = []
+    for flag, fs in v.groupby('flagged'):
+        for name, d in [('ALL', fs)] + list(fs.groupby(fs.dataset_id.str[:3], sort=True)):
+            base = {'dataset': name, 'flagged': bool(flag), 'cells': len(d),
+                    'samples': d.sample_key.nunique(), 'dataset_scoped_donors': len(d[KEY[:2]].drop_duplicates())}
+            for gene in GENES:
+                base[gene + '_detected'] = int((d[gene] > 0).sum())
+                base[gene + '_fraction'] = float((d[gene] > 0).mean())
+                base[gene + '_mean_raw_counts'] = float(d[gene].mean())
+            for k in range(6): base[f'exactly_{k}_detected'] = int((d.markers_detected == k).sum())
+            for name2 in ['all_five_detected', 'c1qa_plus_at_least_three_others']:
+                q = d[d[name2]]
+                base[name2] = len(q)
+                base[name2 + '_samples'] = q.sample_key.nunique()
+                base[name2 + '_dataset_scoped_donors'] = len(q[KEY[:2]].drop_duplicates())
+            groups.append(base)
+    pd.DataFrame(groups).to_csv(ROOT / 'summary.csv', index=False)
+    sample = v.groupby(KEY + ['sample_key', 'flagged'], dropna=False).agg(
+        candidate_cells=('shard_row', 'size'), all_five=('all_five_detected', 'sum'),
+        c1qa_plus_three_others=('c1qa_plus_at_least_three_others', 'sum')).reset_index()
+    sample.to_csv(ROOT / 'sample_support.csv', index=False)
+    labels = v.groupby(['dataset_id', 'source_label']).agg(cells=('shard_row', 'size'),
+              all_five=('all_five_detected', 'sum'), c1qa_plus_three_others=('c1qa_plus_at_least_three_others', 'sum')).reset_index()
+    labels.to_csv(ROOT / 'source_label_summary.csv', index=False)
+    write_json(ROOT / 'expression_source_receipts.json', chunk_receipts)
+    result = {'status': 'verified', 'selection_scope': 'source-annotated C1Q-high candidates in exact registered train split; not all training cells',
+              'detection_rule': 'raw count > 0; descriptive co-detection, not macrophage identity or high-expression gate',
+              'genes': dict(zip(GENES, IDS)), 'WARS1_stored_symbol': 'WARS',
+              'all_markers_measured_in_all_candidate_shards': True, 'counts': groups,
+              'shard_checks': checks, 'input_metadata': plan['metadata_sources'],
+              'input_expression_chunk_receipt': receipt(ROOT / 'expression_source_receipts.json'),
+              'limitations': ['Candidate selection is conditioned on existing C1Q source labels.',
+                              'This does not estimate whole-training-corpus macrophage or marker-positive prevalence.',
+                              'Zero counts are finite-sampling non-detection despite measured gene availability.',
+                              'Co-detection does not establish macrophage rather than monocyte identity.',
+                              'Donor IDs are dataset scoped; cross-dataset person duplication is not resolved.',
+                              'AIDA flagged source annotations remain separate.'],
+              'outputs': [receipt(ROOT / n) for n in ['selected_training_candidates.parquet', 'candidate_marker_counts.parquet',
+                                                    'summary.csv', 'sample_support.csv', 'source_label_summary.csv']]}
+    write_json(ROOT / 'RESULT.json', result)
+    print(pd.DataFrame(groups)[['dataset', 'flagged', 'cells', 'all_five_detected', 'c1qa_plus_at_least_three_others']].to_string(index=False), flush=True)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('stage', choices=['prepare', 'extract'])
+    args = parser.parse_args()
+    globals()[args.stage]()