Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/export_healthy_visuals.py

@@ -0,0 +1,412 @@
+#!/usr/bin/env python3
+"""CPU-only strict Figure 3 visual and operational-time exporter.
+
+Consumes all five finished n=5 ImMicro score calls. Replays the scorer's whole-NPZ
+Poisson readout, selecting the exact generated rows in its P/C subsample. Fits one
+PCA50 and UMAP on pooled real R1 cells, then projects R2 and every generated arm
+into those fixed axes. Never reads legacy native visualization outputs.
+"""
+from __future__ import annotations
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+if os.environ.get('CUDA_VISIBLE_DEVICES') != '':
+    raise SystemExit("Set CUDA_VISIBLE_DEVICES='' for CPU visual export")
+for k in ('OMP_NUM_THREADS','OPENBLAS_NUM_THREADS','MKL_NUM_THREADS','NUMBA_NUM_THREADS'):
+    os.environ.setdefault(k,'4')
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from sklearn.decomposition import PCA
+
+ROOT=Path(__file__).resolve().parents[1]
+M8=ROOT.parents[1]
+OLD=M8/'plans/paired_finetune_intradataset_20260927'
+sys.path.insert(0,str(OLD/'tools'))
+sys.path.insert(0,str(ROOT/'tools'))
+import ft_common as F
+import score_ft as S
+from rare_cache_builder import _score_rows, _stream_poisson, validate_score_arm
+from build_results_figures import ARMS, strict_unit, sha
+from runtime import Runtime
+
+CANON=Path('/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/canonical_genes.tsv')
+MARKERS=('CD3D','CD3E','IL7R','CD4','CD8A','CD8B','MS4A1','CD79A','CD79B',
+         'NKG7','GNLY','KLRD1','LST1','S100A8','S100A9','FCGR3A','FCER1A',
+         'CST3','CLEC10A','PPBP')
+
+
+def marker_axis(score_ids: np.ndarray, canonical: pd.DataFrame) -> tuple[list[str],list[str],np.ndarray]:
+    if not {'gene_symbol','gene_id'} <= set(canonical):
+        raise ValueError('canonical gene table lacks gene_symbol or gene_id')
+    sym2id=dict(zip(canonical.gene_symbol.astype(str),canonical.gene_id.astype(str)))
+    pos={g:i for i,g in enumerate(score_ids.astype(str))}
+    symbols=[s for s in MARKERS if sym2id.get(s) in pos]
+    if len(symbols)<10 or len(set(symbols))!=len(symbols):
+        raise ValueError('too few measured canonical marker genes')
+    ids=[sym2id[s] for s in symbols]
+    return symbols,ids,np.asarray([pos[g] for g in ids],dtype=np.int64)
+
+
+def unit_inputs() -> list[dict]:
+    units=[]
+    for i in range(5):
+        path=ROOT/'protocol/splits/immicro/healthy'/f'fold{i}'/'n5/support.json'
+        if not path.is_file(): raise FileNotFoundError(path)
+        unit,reason=strict_unit(path)
+        if unit is None: raise ValueError(f'fold{i} strict score incomplete: {reason}')
+        if unit['support']['n_pairs']!=5 or unit['support']['design']!='healthy_outerfold':
+            raise ValueError('Figure 3 requires exact five-pair healthy outer folds')
+        expected_cells=1500*len(unit['support']['test_sample_ids'])
+        for arm in ARMS:
+            if unit['summary']['per_arm'][arm].get('n_generated_cells')!=expected_cells:
+                raise ValueError(f'Figure 3 {arm} generation budget differs from 1,500 per test sample')
+        units.append(unit)
+    seen=[s for u in units for s in u['support']['test_sample_ids']]
+    if len(seen)!=107 or len(set(seen))!=107:
+        raise ValueError('healthy OOF requires exactly 107 disjoint test samples across folds')
+    return units
+
+
+def resource_preflight(units: list[dict]) -> None:
+    Runtime(ROOT).preflight('cpu',memory_gib=16)
+    largest=0
+    for source in {u['summary']['per_arm'][arm]['npz'] for u in units for arm in ARMS}:
+        with zipfile.ZipFile(source) as z:
+            largest=max(largest,z.getinfo('generated_counts.npy').file_size)
+    free=shutil.disk_usage(ROOT/'source_data').free
+    if free < largest + (2<<30):
+        raise OSError(f'Figure 3 streamed NPZ needs at least {largest+(2<<30)} free bytes; only {free} available')
+
+
+def receipt_seconds(path: Path, required_output: Path | None = None) -> tuple[float,dict]:
+    if not path.is_file(): raise FileNotFoundError(path)
+    r=json.loads(path.read_text())
+    if r.get('state')!='completed' or not np.isfinite(r.get('seconds',float('nan'))) or r['seconds']<0:
+        raise ValueError(f'incomplete runtime receipt: {path}')
+    if required_output is not None:
+        entries={Path(x['path']).resolve():x for x in r.get('outputs',[])}
+        actual=required_output.resolve()
+        if actual not in entries or entries[actual].get('sha256')!=sha(required_output):
+            raise ValueError(f'runtime receipt does not bind output: {path}')
+    return float(r['seconds']),{'path':str(path.resolve()),'sha256':sha(path),'seconds':float(r['seconds'])}
+
+
+def global_allocation(units: list[dict]) -> dict[str,float]:
+    total=sum(len(u['support']['test_sample_ids']) for u in units)
+    if total<=0:raise ValueError('no strict held-out samples for global generation allocation')
+    return {u['rel']:len(u['support']['test_sample_ids'])/total for u in units}
+
+
+def operational_runtime(units: list[dict]) -> tuple[list[dict],dict]:
+    """Split comparable GPU-job wall time into adaptation and generation."""
+    rows=[]; evidence={'schema':'pbisc.fig3.runtime-evidence.v1','pretraining_excluded':True,
+                       'runtime_scope':'gpu_job_wall_seconds_only','units':{}}
+    allocation=global_allocation(units)
+    global_time={}
+    for arm in ('raw','refcal'):
+        p=ROOT/'receipts'/f'global-immicro-{arm}.json'
+        seconds,rec=receipt_seconds(p,ROOT/'generated/global/immicro'/f'{arm}.npz')
+        global_time[arm]=(seconds,rec)
+    for u in units:
+        rel=u['rel']; fold=u['support']['unit'].split('_')[0]
+        tag='immicro-healthy-'+fold+'-n5'
+        run=ROOT/'runs'/rel/'lora/RUN.json'
+        if not run.is_file(): raise FileNotFoundError(run)
+        rd=json.loads(run.read_text())
+        if (rd.get('support_sha256')!=u['support']['sha256'] or rd.get('fixed_steps')!=3000
+            or rd.get('selected_step')!=3000 or not np.isfinite(rd.get('wall_seconds',float('nan')))):
+            raise ValueError(f'LoRA runtime RUN.json does not bind strict support: {run}')
+        train_seconds,train_rec=receipt_seconds(ROOT/'receipts'/f'{tag}-train.json',run)
+        if abs(train_seconds-float(rd['wall_seconds']))>max(60.0,0.25*train_seconds):
+            raise ValueError(f'LoRA run and training receipt times differ: {run}')
+        vals={}
+        for arm in ('raw','refcal'):
+            seconds,rec=global_time[arm]
+            vals[arm]={'adaptation_seconds':0.0,'generation_seconds':seconds*allocation[rel],
+                       'scope':'cohort_global_gpu_sampling_apportioned_by_held_out_sample_count',
+                       'sources':[rec]}
+        lora_sample,lora_rec=receipt_seconds(ROOT/'receipts'/f'{tag}-lora.json',ROOT/'generated'/rel/'lora.npz')
+        vals['lora']={'adaptation_seconds':train_seconds,'generation_seconds':lora_sample,
+                      'scope':'fold_gpu_training_plus_gpu_sampling',
+                      'sources':[{'path':str(run.resolve()),'sha256':sha(run),'wall_seconds':float(rd['wall_seconds'])},train_rec,lora_rec]}
+        pc_seconds,pc_rec=receipt_seconds(ROOT/'receipts'/f'{tag}-pairedcal.json',ROOT/'generated'/rel/'pairedcal.npz')
+        vals['pairedcal']={'adaptation_seconds':0.0,'generation_seconds':pc_seconds,
+                           'scope':'fold_generation_calibration_prepared_separately',
+                           'sources':[pc_rec]}
+        files=[];phase_seconds={'scpretrain':0.0,'scinfer':0.0}
+        for suffix in ('scinputs','scprepare','scexport','scvalidate'):
+            p=ROOT/'receipts'/f'{tag}-{suffix}.json'
+            _,r=receipt_seconds(p, ROOT/'generated'/rel/'scsemi.npz' if suffix=='scexport' else None)
+            files.append(r)
+        for phase in ('scpretrain','scinfer'):
+            found=sorted((ROOT/'receipts').glob(f'{tag}-{phase}-*.json'))
+            if not found: raise ValueError(f'missing scSemi {phase} receipts for {tag}')
+            for p in found:
+                seconds,r=receipt_seconds(p);files.append(r);phase_seconds[phase]+=seconds
+        scstatus=ROOT/'scsemi'/rel/'status.json'
+        status=json.loads(scstatus.read_text())
+        if not status.get('pretrain_complete') or not status.get('infer_complete'):
+            raise ValueError(f'scSemi work incomplete: {scstatus}')
+        files.append({'path':str(scstatus.resolve()),'sha256':sha(scstatus),'status':'complete'})
+        vals['scsemi']={'adaptation_seconds':phase_seconds['scpretrain'],
+                        'generation_seconds':phase_seconds['scinfer'],
+                        'scope':'fold_scsemi_gpu_pretrain_and_infer_only',
+                        'excluded_cpu_seconds':sum(x.get('seconds',0) for x in files)
+                        -sum(phase_seconds.values()),
+                        'sources':files}
+        evidence['units'][rel]=vals
+        for arm in ARMS:
+            component=vals[arm]
+            rows.append({'fold':u['support']['unit'],'arm':arm,
+                         'adaptation_seconds':component['adaptation_seconds'],
+                         'generation_seconds':component['generation_seconds'],
+                         'operational_seconds':component['adaptation_seconds']+component['generation_seconds'],
+                         'scope':component['scope'],
+                         'support_sha256':u['support']['sha256']})
+    return rows,evidence
+
+
+def replay_scored_arm(u: dict,arm: str, score_ids: np.ndarray, score_idx: np.ndarray,
+                      marker_idx: np.ndarray, temp_dir: Path) -> tuple[sp.csr_matrix,np.ndarray,np.ndarray]:
+    """Return exact P/C subsample counts and aligned labels/sample IDs."""
+    score=Path(u['summary_path']).parent
+    source=Path(u['summary']['per_arm'][arm]['npz'])
+    checksum=sha(source)
+    validate_score_arm(score,arm,source,checksum,u['support'])
+    gc,lab=_score_rows(score,arm,u['support'])
+    sub=gc.in_pc_subsample.to_numpy(dtype=bool)
+    if not sub.any(): raise ValueError(f'{arm}: no scored P/C subsample')
+    sample=gc.loc[sub,'donor'].astype(str).to_numpy()
+    label=lab.loc[sub,'aifi_l1'].astype(str).to_numpy()
+    selected=gc.loc[sub,'npz_row'].to_numpy(dtype=np.int64)
+    with zipfile.ZipFile(source) as z:
+        with z.open('gene_ids.npy') as f: genes=np.load(f,allow_pickle=False).astype(str)
+        with z.open('sample_ids.npy') as f: sample_ids=np.load(f,allow_pickle=False).astype(str)
+        with z.open('bulk_index.npy') as f: bulk=np.load(f,allow_pickle=False).astype(int)
+        if (not np.array_equal(genes[score_idx],score_ids) or selected.max()>=len(bulk)
+            or not np.array_equal(sample_ids[bulk[selected]],sample)):
+            raise ValueError(f'{arm}: generated NPZ row/gene/sample mismatch')
+        temp=temp_dir/f'{arm}_rates.npy'
+        with z.open('generated_counts.npy') as src,temp.open('wb') as dst:
+            shutil.copyfileobj(src,dst,length=4<<20)
+        rates=np.load(temp,mmap_mode='r',allow_pickle=False)
+        measured=np.zeros(len(genes),dtype=bool);measured[score_idx]=True
+        counts,_,umi=_stream_poisson(rates,selected,measured,score_idx,score_idx,chunk_rows=512)
+        del rates
+        temp.unlink()
+    if not np.array_equal(umi,gc.loc[sub,'umi_scoring_genes'].to_numpy()):
+        raise ValueError(f'{arm}: replayed Poisson UMI differs from scored cells')
+    return sp.csr_matrix(counts),sample,label
+
+
+def embed_reference(r1: sp.csr_matrix, others: list[sp.csr_matrix]):
+    """One fixed real-R1 fit; each candidate is projected into that fit."""
+    import umap
+    X1=F.SB.cp10k_log1p(r1)
+    ncomp=min(50,X1.shape[0]-1,X1.shape[1])
+    if ncomp<2: raise ValueError('insufficient real R1 cells or measured genes')
+    pca=PCA(n_components=ncomp,svd_solver='randomized',random_state=20261012).fit(X1)
+    z1=pca.transform(X1).astype(np.float32)
+    model=umap.UMAP(n_neighbors=15,min_dist=.3,n_components=2,random_state=20261012,
+                    transform_seed=20261012).fit(z1)
+    coords=[model.embedding_.astype(np.float32)]
+    for x in others:
+        z=F.SB.project(x,pca.mean_.astype(np.float32),pca.components_.astype(np.float32))
+        coords.append(model.transform(z).astype(np.float32))
+    return coords,pca,model
+
+
+def scored_composition_rows(units: list[dict]) -> list[dict]:
+    """Full scored 1,500-cell generation and all observed QC cells per test sample."""
+    labels=tuple(map(str,F.GATE));result=[]
+    for u in units:
+        source=Path(u['per_path'])
+        if not source.is_file():raise FileNotFoundError(source)
+        digest=sha(source)
+        for row in u['rows']:
+            n_gen=int(row['n_generated_cells']);n_obs=int(row['n_observed_cells'])
+            if n_gen!=1500 or n_obs<=0:
+                raise ValueError(f'Figure 3 composition requires 1,500 generated and positive observed cells: {row["donor"]}')
+            obs=np.asarray([float(row[f'obs_{name}']) for name in labels])
+            gen=np.asarray([float(row[f'gen_{name}']) for name in labels])
+            if (not np.isfinite(obs).all() or not np.isfinite(gen).all()
+                or np.min(obs)<0 or np.min(gen)<0 or np.max(obs)>1 or np.max(gen)>1
+                or not np.isclose(obs.sum(),1,atol=1e-5)
+                or not np.isclose(gen.sum(),1,atol=1e-5)):
+                raise ValueError(f'Figure 3 composition fractions invalid: {row["donor"]}/{row["arm"]}')
+            for j,name in enumerate(labels):
+                result.append({'fold':u['support']['unit'],'arm':row['arm'],'sample_id':row['donor'],
+                               'cell_type':name,'observed_total':n_obs,'generated_total':n_gen,
+                               'observed_fraction':float(obs[j]),'generated_fraction':float(gen[j]),
+                               'delta_pp':100*float(gen[j]-obs[j]),
+                               'score_per_donor_sha256':digest})
+    return result
+
+
+def build():
+    units=unit_inputs() # all read-only checks before substantial arrays
+    runtime_rows,evidence=operational_runtime(units)
+    resource_preflight(units)
+    ref_path=Path(units[0]['summary']['reference']['cache'])
+    if any(Path(u['summary']['reference']['cache']).resolve()!=ref_path.resolve() for u in units):
+        raise ValueError('five folds use different observed reference caches')
+    ref,manifest=F.load_reference(ref_path)
+    if any(u['summary']['reference']['reference_sha256']!=manifest['reference_sha256'] for u in units):
+        raise ValueError('scored reference hash differs from loaded real cells')
+    score_ids=ref['score_ids'].astype(str);score_idx=ref['score_idx'].astype(np.int64)
+    if not np.array_equal(ref['panel_ids'][score_idx].astype(str),score_ids):
+        raise ValueError('reference score/panel gene axis mismatch')
+    canonical=pd.read_csv(CANON,sep='\t',dtype=str)
+    symbols,ids,marker_idx=marker_axis(score_ids,canonical)
+    r1s=[];r2s=[];r1_sample=[];r2_sample=[];r1_labels=[];r2_labels=[]
+    for u in units:
+        view=S.make_view(ref,u['support']['test_sample_ids'])
+        selected=set(u['support']['test_sample_ids'])
+        for side,outm,outs,outl in (('r1',r1s,r1_sample,r1_labels),('r2',r2s,r2_sample,r2_labels)):
+            mask=np.isin(ref[f'{side}_donor'],[np.where(ref['donors'].astype(str)==s)[0][0] for s in selected])
+            matrix=view[side.upper()]
+            if mask.sum()!=matrix.shape[0]: raise ValueError('real reference/view row mismatch')
+            outm.append(matrix)
+            outs.extend(ref['donors'][ref[f'{side}_donor'][mask]].astype(str).tolist())
+            outl.extend(ref[f'{side}_label'][mask].astype(str).tolist())
+        del view
+    real1=sp.vstack(r1s,format='csr');real2=sp.vstack(r2s,format='csr')
+    del ref,r1s,r2s
+    # Fit once on all out-of-fold real R1 cells; R2 and generated use fixed axes.
+    xy, pca, model=embed_reference(real1,[real2])
+    arrays={'xy':[xy[0],xy[1]],'arm':[np.repeat('real_R1',real1.shape[0]),np.repeat('real_R2',real2.shape[0])],
+            'cell_type':[np.asarray(r1_labels),np.asarray(r2_labels)],
+            'sample_id':[np.asarray(r1_sample),np.asarray(r2_sample)],
+            'marker_values':[F.SB.cp10k_log1p(real1)[:,marker_idx],F.SB.cp10k_log1p(real2)[:,marker_idx]],
+            'marker_detected':[np.asarray(real1[:,marker_idx].toarray()>0,dtype=np.uint8),
+                               np.asarray(real2[:,marker_idx].toarray()>0,dtype=np.uint8)]}
+    del real1,real2,xy
+    import umap # explicitly bind UMAP implementation in receipt
+    with tempfile.TemporaryDirectory(prefix='fig3-rates-',dir=ROOT/'source_data') as tmp:
+        for u in units:
+            with tempfile.TemporaryDirectory(prefix='unit-',dir=tmp) as unit_tmp:
+                for arm in ARMS:
+                    counts,samples,labels=replay_scored_arm(u,arm,score_ids,score_idx,marker_idx,Path(unit_tmp))
+                    z=F.SB.project(counts,pca.mean_.astype(np.float32),pca.components_.astype(np.float32))
+                    coord=model.transform(z).astype(np.float32)
+                    arrays['xy'].append(coord)
+                    arrays['arm'].append(np.repeat(arm,len(samples)))
+                    arrays['cell_type'].append(labels)
+                    arrays['sample_id'].append(samples)
+                    arrays['marker_values'].append(F.SB.cp10k_log1p(counts)[:,marker_idx])
+                    arrays['marker_detected'].append(np.asarray(counts[:,marker_idx].toarray()>0,dtype=np.uint8))
+                    del counts,z,coord
+    out=ROOT/'source_data';out.mkdir(exist_ok=True)
+    visual=out/'fig3_visual_data.npz';sidecar=out/'fig3_visual_data.json'
+    values={k:np.concatenate(v,axis=0) for k,v in arrays.items()}
+    values['marker_symbols']=np.asarray(symbols)
+    values['marker_gene_ids']=np.asarray(ids)
+    coordinates=out/'fig3_umap_coordinates.csv'
+    pd.DataFrame({'umap_x':values['xy'][:,0],'umap_y':values['xy'][:,1],
+                  'arm':values['arm'],'cell_type':values['cell_type'],
+                  'sample_id':values['sample_id']}).to_csv(coordinates,index=False)
+    composition=pd.DataFrame(scored_composition_rows(units))
+    composition.to_csv(out/'fig3_celltype_fractions.csv',index=False)
+    codetect=[]
+    for arm in ('real_R1','real_R2',*ARMS):
+        arm_mask=values['arm']==arm
+        for cell_type in sorted(set(values['cell_type'][arm_mask].astype(str))):
+            mask=arm_mask & (values['cell_type']==cell_type)
+            binary=values['marker_detected'][mask].astype(np.int64)
+            pair=binary.T @ binary
+            for i,s1 in enumerate(symbols):
+                for j in range(i,len(symbols)):
+                    codetect.append({'arm':arm,'cell_type':cell_type,'marker_a':s1,
+                                     'marker_b':symbols[j],'n_cells':int(mask.sum()),
+                                     'n_codetected':int(pair[i,j])})
+    pd.DataFrame(codetect).to_csv(out/'fig3_marker_codetection.csv',index=False)
+    np.savez_compressed(visual,**values)
+    receipt={'schema':'pbisc.fig3.visual.v1','npz_sha256':sha(visual),
+             'support_sha256s':[u['support']['sha256'] for u in units],
+             'score_sha256s':[sha(Path(u['summary_path'])) for u in units],
+             'score_binding_sha256s':[u['binding_sha256'] for u in units],
+             'generated_npz_sha256s':[u['summary']['per_arm'][a]['npz_sha256'] for u in units for a in ARMS],
+             'reference_fit':'real_R1_only','projection':'fixed_real_R1_pca_umap',
+             'pca_components':int(pca.n_components_),'umap_seed':20261012,'umap_neighbors':15,'umap_min_dist':.3,
+             'umap_version':getattr(umap,'__version__','unknown'),
+             'canonical_marker_gene_ids':ids,'canonical_marker_symbols':symbols,
+             'reference_npz':str((ref_path/'reference.npz').resolve()),
+             'reference_sha256':manifest['reference_sha256'],
+             'coordinates_csv':str(coordinates.resolve()),'coordinates_sha256':sha(coordinates),
+             'composition_csv':str((out/'fig3_celltype_fractions.csv').resolve()),
+             'composition_sha256':sha(out/'fig3_celltype_fractions.csv'),
+             'cells':int(len(values['arm'])),'pretraining_excluded':True}
+    sidecar.write_text(json.dumps(receipt,indent=2)+'\n')
+    evidence_path=out/'fig3_runtime_evidence.json'
+    evidence_path.write_text(json.dumps(evidence,indent=2)+'\n')
+    for r in runtime_rows:
+        r['receipt_path']=str(evidence_path.resolve())
+        r['receipt_sha256']=sha(evidence_path)
+    runtime=out/'fig3_runtime.csv'
+    pd.DataFrame(runtime_rows).to_csv(runtime,index=False)
+    (out/'fig3_runtime.json').write_text(json.dumps({'schema':'pbisc.fig3.runtime.v2',
+        'csv_sha256':sha(runtime),'support_sha256s':[u['support']['sha256'] for u in units],
+        'pretraining_excluded':True,'runtime_scope':'gpu_job_wall_seconds_only',
+        'components':['adaptation_seconds','generation_seconds'],
+        'global_generation_allocation':'held_out_test_samples_per_fold_over_total_107'},indent=2)+'\n')
+    print(json.dumps({'visual':str(visual),'runtime':str(runtime),'cells':len(values['arm'])}))
+
+
+def self_test():
+    from rare_cache_builder import _stream_poisson
+    rates=np.array([[1.2,.5,0.0],[0.2,2.1,1.0],[3.0,0.0,.1]],dtype=float)
+    selected=np.array([2,0],dtype=np.int64)
+    whole=np.random.default_rng(20260916).poisson(rates)
+    got,_,umi=_stream_poisson(rates,selected,np.ones(3,bool),np.arange(3),np.arange(3),chunk_rows=2)
+    assert np.array_equal(got,whole[selected]) and np.array_equal(umi,whole[selected].sum(1))
+    canonical=pd.DataFrame({'gene_symbol':list(MARKERS),'gene_id':[f'g{i}' for i in range(len(MARKERS))]})
+    sym,ids,ix=marker_axis(np.asarray([f'g{i}' for i in range(len(MARKERS))]),canonical)
+    assert len(sym)==len(MARKERS) and np.array_equal(ix,np.arange(len(MARKERS)))
+    weights=global_allocation([{'rel':'a','support':{'test_sample_ids':['1','2']}},
+                               {'rel':'b','support':{'test_sample_ids':['3','4','5']}}])
+    assert abs(weights['a']-.4)<1e-12 and abs(weights['b']-.6)<1e-12
+    gate=tuple(F.GATE)
+    with tempfile.TemporaryDirectory() as tmp:
+        score=Path(tmp)/'per_donor.csv';score.write_text('fixture\n')
+        per=[]
+        for arm in ARMS:
+            row={'arm':arm,'donor':'S','n_generated_cells':1500,'n_observed_cells':2000}
+            row.update({f'obs_{name}':1.0 if j==0 else 0.0 for j,name in enumerate(gate)})
+            row.update({f'gen_{name}':.5 if j<2 else 0.0 for j,name in enumerate(gate)})
+            per.append(row)
+        u={'support':{'unit':'fold0_n5'},'rows':per,'per_path':str(score)}
+        comp=scored_composition_rows([u])
+        assert len(comp)==len(ARMS)*len(gate)
+        b=next(r for r in comp if r['arm']==ARMS[0] and r['cell_type']==gate[1])
+        assert b['observed_fraction']==0 and b['generated_fraction']==.5
+        per[0]['n_generated_cells']=1499
+        try:scored_composition_rows([u])
+        except ValueError as e:assert '1,500 generated' in str(e)
+        else:raise AssertionError('composition accepted incomplete generated cell budget')
+    print('Figure 3 exporter self-test passed: Poisson row order, marker axis, full-cell composition')
+
+
+def self_test_embedding():
+    rng=np.random.default_rng(7)
+    real=sp.csr_matrix(rng.poisson(2.0,size=(32,60)).astype(np.int32))
+    other=sp.csr_matrix(rng.poisson(2.0,size=(7,60)).astype(np.int32))
+    xy,pca,_=embed_reference(real,[other])
+    assert xy[0].shape==(32,2) and xy[1].shape==(7,2)
+    assert np.isfinite(xy[0]).all() and np.isfinite(xy[1]).all()
+    assert pca.n_components_==31
+    print('Figure 3 embedding fixture passed: one real-R1 fit, projected candidate')
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('--self-test',action='store_true')
+    p.add_argument('--self-test-embedding',action='store_true')
+    args=p.parse_args()
+    if args.self_test: self_test()
+    elif args.self_test_embedding: self_test_embedding()
+    else: build()

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/export_rare_visuals.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""Strict Figure 5 marker-space illustrations from complete scored cache manifests.
+
+Each donor is assigned one available held-out draw by a fixed hash, before state calls.
+PCA and UMAP fit observed cells only; generated cells use that frozen transform.
+The projection is a marker-space illustration, separate from all-draw numeric scores.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("rare-state visuals require CUDA_VISIBLE_DEVICES=''")
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import StandardScaler
+
+from build_figure5 import (HERE, STATES, STRICT_ARMS, _load, _metadata, _parent, _seed,
+                           _sha256, _thin_depth, _thin_subset, require_complete_strict,
+                           validate_strict_cache)
+from rare_metrics import call_marker_state, validate_marker_coverage
+
+EXAMPLES = (
+    {"slug": "sepsis_ms1", "cohort": "ye2026_sepsis", "state": "MS1 monocyte (IL1R2+)"},
+    {"slug": "sepsis_cycling_monocyte", "cohort": "ye2026_sepsis",
+     "state": "Cycling monocyte (Ye 2026)"},
+    {"slug": "imperial_cycling_tnk", "cohort": "imperial_eskd", "state": "Cycling T/NK"},
+)
+ARM_ORDER = ("observed", "raw", "refcal", "pairedcal", "scsemi", "lora")
+SEED = 20261012
+
+
+def choose_donor_draws(units: list[dict], cohort: str, metadata: pd.DataFrame) -> dict[str, str]:
+    """Select one available held-out draw per actual donor, independent of any result."""
+    mapping = metadata.set_index("sample_id").donor_id.astype(str)
+    available: dict[str, set[str]] = {}
+    for unit in units:
+        if unit["cohort"] != cohort:
+            continue
+        for sample in unit["test_sample_ids"]:
+            if sample not in mapping:
+                raise ValueError(f"{cohort}: sample {sample} lacks donor metadata")
+            available.setdefault(mapping[sample], set()).add(unit["unit"])
+    selected = {}
+    for donor, draws in available.items():
+        ordered = sorted(draws)
+        digest = hashlib.sha256(f"{SEED}|{cohort}|{donor}".encode()).digest()
+        selected[donor] = ordered[int.from_bytes(digest[:8], "little") % len(ordered)]
+    return selected
+
+
+def read_units(manifest_dir: Path) -> list[dict]:
+    paths = sorted(manifest_dir.rglob("rare_manifest.json"))
+    units = []
+    for path in paths:
+        doc = json.loads(path.read_text())
+        if doc.get("schema") != "pbisc.figure5.marker-caches.v1":
+            raise ValueError(f"wrong rare marker manifest schema: {path}")
+        for raw in doc["units"]:
+            unit = dict(raw)
+            for key in ("sample_metadata", "support_manifest", "observed_cache"):
+                unit[key] = str((path.parent / unit[key]).resolve())
+            unit["generated_caches"] = {a: str((path.parent / p).resolve())
+                                        for a, p in unit["generated_caches"].items()}
+            units.append(unit)
+    require_complete_strict(units)
+    return units
+
+
+def _check_unit(unit: dict) -> dict:
+    support = json.loads(Path(unit["support_manifest"]).read_text())
+    body = {k: v for k, v in support.items() if k != "sha256"}
+    digest = hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"),
+                                       allow_nan=False).encode()).hexdigest()
+    if (support.get("schema") != "pbisc.paper.strict-support.v1" or
+        support.get("sha256") != digest or support.get("cohort") != unit["cohort"] or
+        support.get("unit") != f'{unit["unit"]}_n5' or
+        support.get("test_sample_ids") != unit["test_sample_ids"] or
+        support.get("train_sample_ids") != unit["train_sample_ids"] or
+        support.get("train_donor_ids") != unit["train_donor_ids"]):
+        raise ValueError("visual cache support mismatch")
+    if _sha256(Path(unit["observed_cache"])) != unit.get("observed_cache_sha256"):
+        raise ValueError("visual observed cache hash mismatch")
+    checked = {**unit, "test_donor_ids": support["test_donor_ids"]}
+    for arm, path in unit["generated_caches"].items():
+        cache = _load(Path(path))
+        validate_strict_cache(cache, Path(path), checked, arm, support["sha256"])
+        if set(cache["sample_id"].astype(str)) != set(unit["test_sample_ids"]):
+            raise ValueError(f"{arm}: visual scored sample set differs from strict support")
+    return support
+
+
+def _selected_parent_cells(unit: dict, chosen: dict[str, str], state: dict,
+                           cells_per_sample: int) -> tuple[list[dict], list[str]]:
+    metadata = _metadata(Path(unit["sample_metadata"]))
+    obs = _load(Path(unit["observed_cache"]))
+    generated = {arm: _load(Path(path)) for arm, path in unit["generated_caches"].items()}
+    symbols = list(obs["marker_symbols"].astype(str))
+    validate_marker_coverage(state, symbols)
+    if any(list(cache["marker_symbols"].astype(str)) != symbols for cache in generated.values()):
+        raise ValueError("visual marker columns differ across methods")
+    records = []
+    obs_ids = obs["sample_id"].astype(str)
+    gen_ids = {arm: cache["sample_id"].astype(str) for arm, cache in generated.items()}
+    for sample in unit["test_sample_ids"]:
+        donor = str(metadata.loc[sample].donor_id)
+        if chosen.get(donor) != unit["unit"]:
+            continue
+        ids = {arm: np.flatnonzero(values == sample) for arm, values in gen_ids.items()}
+        oidx = np.flatnonzero(obs_ids == sample)
+        budget = min(cells_per_sample, int(unit["cell_budget"]), len(oidx),
+                     *(len(v) for v in ids.values()))
+        if budget <= 0:
+            raise ValueError(f"{sample}: no common cells for visual")
+        for arm in ARM_ORDER:
+            cache = obs if arm == "observed" else generated[arm]
+            idx = oidx if arm == "observed" else ids[arm]
+            x = _thin_depth(_thin_subset(
+                cache, idx, budget, _seed(unit["cohort"], unit["unit"], sample, "visual", arm)),
+                float(unit["depth_target"]),
+                _seed(unit["cohort"], unit["unit"], sample, "visual", arm, "depth"))
+            parent = _parent(x, state)
+            hits = call_marker_state(x["markers"], symbols, state) & parent
+            records.append(dict(arm=arm, cohort=unit["cohort"], draw=unit["unit"],
+                                donor_id=donor, sample_id=sample, group=str(metadata.loc[sample].group),
+                                markers=x["markers"][parent], hits=hits[parent],
+                                selected_all_cells=budget, selected_parent_cells=int(parent.sum()),
+                                selected_cells_below_depth_target=x["below_target"],
+                                depth_target=float(unit["depth_target"])))
+    return records, symbols
+
+
+def _make_projection(records: list[dict], symbols: list[str], example: dict,
+                     state: dict) -> tuple[pd.DataFrame, pd.DataFrame]:
+    real = [r["markers"] for r in records if r["arm"] == "observed" and len(r["markers"])]
+    if not real or sum(len(x) for x in real) < 16:
+        raise ValueError("fewer than 16 real parent cells for 15-neighbor UMAP")
+    observed = np.vstack(real)
+    scaler = StandardScaler().fit(np.log1p(observed))
+    n_components = min(20, len(symbols), len(observed) - 1)
+    pca = PCA(n_components=n_components, random_state=SEED).fit(scaler.transform(np.log1p(observed)))
+    real_pc = pca.transform(scaler.transform(np.log1p(observed)))
+    import umap
+    mapper = umap.UMAP(n_neighbors=15, n_components=2, min_dist=.15,
+                       random_state=SEED, transform_seed=SEED, n_jobs=1).fit(real_pc)
+    cells, heat = [], []
+    genes = list(dict.fromkeys(state["genes"] +
+                [g for grp in state.get("require_any", []) for g in grp] + state.get("exclude", [])))
+    pos = {g: i for i, g in enumerate(symbols)}
+    real_cursor = 0
+    for record in records:
+        counts = record["markers"]
+        if not len(counts):
+            continue
+        if record["arm"] == "observed":
+            xy = mapper.embedding_[real_cursor:real_cursor + len(counts)]
+            real_cursor += len(counts)
+        else:
+            pc = pca.transform(scaler.transform(np.log1p(counts)))
+            xy = mapper.transform(pc)
+        for k in range(len(counts)):
+            cells.append(dict(example=example["slug"], cohort=example["cohort"],
+                              state=example["state"], arm=record["arm"],
+                              donor_id=record["donor_id"], sample_id=record["sample_id"],
+                              selected_draw=record["draw"], group=record["group"],
+                              state_hit=bool(record["hits"][k]), umap1=float(xy[k, 0]),
+                              umap2=float(xy[k, 1]), projection_fit_source="observed_only",
+                              projection_space="measured_marker_counts",
+                              depth_target=record["depth_target"],
+                              cell_budget_used=record["selected_all_cells"]))
+    for arm in ARM_ORDER:
+        xs = [r["markers"] for r in records if r["arm"] == arm and len(r["markers"])]
+        if not xs:
+            continue
+        x = np.vstack(xs)
+        positive = (x[:, [pos[g] for g in state["genes"]]] > 0).sum(axis=1)
+        for gene in genes:
+            c = x[:, pos[gene]]
+            heat.append(dict(example=example["slug"], cohort=example["cohort"],
+                             state=example["state"], arm=arm, marker=gene,
+                             n_parent_cells=len(x), detection_pct=100*float((c > 0).mean()),
+                             mean_count=float(c.mean()), codetection_pct=100*float((positive >= 2).mean()),
+                             depth_target=records[0]["depth_target"]))
+    return pd.DataFrame(cells), pd.DataFrame(heat)
+
+
+def _plot_panels(cells: pd.DataFrame, heat: pd.DataFrame, statuses: list[dict], out: Path) -> None:
+    fig, axs = plt.subplots(len(EXAMPLES), 3, figsize=(13, 11), constrained_layout=True)
+    plt.rcParams.update({"font.family": "DejaVu Sans", "font.size": 8, "pdf.fonttype": 42})
+    for row, example in enumerate(EXAMPLES):
+        ex = cells[cells.example == example["slug"]]
+        hm = heat[heat.example == example["slug"]]
+        status = next(s for s in statuses if s["example"] == example["slug"])
+        if status["status"] != "available":
+            for ax in axs[row]:
+                ax.axis("off")
+                ax.text(.02, .8, f'{example["state"]}: unavailable\n{status["reason"]}',
+                        transform=ax.transAxes, va="top")
+            continue
+        real = ex[ex.arm == "observed"]
+        lora = ex[ex.arm == "lora"]
+        for col, foreground in ((0, real), (1, lora)):
+            ax = axs[row, col]
+            ax.scatter(real.umap1, real.umap2, s=2, color="#bfc9cc", alpha=.35)
+            if col == 1:
+                ax.scatter(lora.umap1, lora.umap2, s=3, color="#81b6bf", alpha=.22)
+            rare = foreground[foreground.state_hit.astype(bool)]
+            ax.scatter(rare.umap1, rare.umap2, s=8, color="#c14c40", alpha=.85)
+            ax.set_xlabel("UMAP 1")
+            ax.set_ylabel("UMAP 2")
+            ax.set_title(f'{example["state"]}\n' +
+                         ("real held-out reference" if col == 0 else "LoRA projected onto real map"))
+        ax = axs[row, 2]
+        mat = hm.pivot(index="marker", columns="arm", values="detection_pct")
+        mat = mat.reindex(columns=[a for a in ARM_ORDER if a in mat.columns])
+        cod = hm.groupby("arm").codetection_pct.first().reindex(mat.columns)
+        mat.loc["≥2 positive markers"] = cod
+        img = ax.imshow(mat.to_numpy(), aspect="auto", cmap="magma", vmin=0,
+                        vmax=max(5, float(np.nanmax(mat.to_numpy()))))
+        ax.set_xticks(range(len(mat.columns)), mat.columns, rotation=35, ha="right")
+        ax.set_yticks(range(len(mat.index)), mat.index)
+        ax.set_title("Detected cells (%) + codetection")
+        fig.colorbar(img, ax=ax, fraction=.045, pad=.02)
+    fig.suptitle("Figure 5 rare-state visual examples · real-only marker-space projection\n"
+                 "One held-out draw per donor fixed by hash; all-draw numeric results shown separately",
+                 fontsize=13, weight="bold")
+    (out / "figures").mkdir(parents=True, exist_ok=True)
+    for ext in ("pdf", "svg", "png"):
+        fig.savefig(out / "figures" / f"fig5_rare_visuals_strict.{ext}", dpi=220, bbox_inches="tight")
+    plt.close(fig)
+
+
+def build_visuals(units: list[dict], out: Path, *, require_complete: bool = True,
+                  validate_sources: bool = True, cells_per_sample: int = 100) -> dict:
+    if require_complete:
+        require_complete_strict(units)
+        prior = json.loads((out / "reports/rare_provenance.json").read_text())
+        if (len(prior.get("units", [])) != 20 or
+            {u.get("evidence_tier") for u in prior["units"]} != {"strict"}):
+            raise ValueError("complete strict rare numeric analysis required before visuals")
+    if cells_per_sample <= 0:
+        raise ValueError("visual cells_per_sample must be positive")
+    if len({float(u["depth_target"]) for u in units}) != 1:
+        raise ValueError("visual input has mixed depth target")
+    if len({int(u["cell_budget"]) for u in units}) != 1:
+        raise ValueError("visual input has mixed cell budget")
+    states = {s["name"]: s for s in json.loads(STATES.read_text())}
+    all_cells, all_heat, statuses, choices = [], [], [], []
+    for example in EXAMPLES:
+        cohort_units = [u for u in units if u["cohort"] == example["cohort"]]
+        if not cohort_units:
+            statuses.append(dict(example=example["slug"], status="unavailable",
+                                 reason="cohort cache absent"))
+            continue
+        meta = pd.read_csv(cohort_units[0]["sample_metadata"], dtype=str)
+        chosen = choose_donor_draws(cohort_units, example["cohort"], meta)
+        choices.extend(dict(example=example["slug"], cohort=example["cohort"],
+                            donor_id=d, selected_draw=draw, rule="sha256(seed|cohort|donor) mod available draws")
+                       for d, draw in chosen.items())
+        state = states[example["state"]]
+        records, symbols = [], None
+        try:
+            for unit in cohort_units:
+                if not any(draw == unit["unit"] for draw in chosen.values()):
+                    continue
+                if validate_sources:
+                    _check_unit(unit)
+                subset, syms = _selected_parent_cells(unit, chosen, state, cells_per_sample)
+                if symbols is not None and symbols != syms:
+                    raise ValueError("marker symbols differ across selected draws")
+                symbols = syms
+                records.extend(subset)
+            if not records:
+                raise ValueError("no selected held-out cells")
+            cells, heat = _make_projection(records, symbols, example, state)
+            all_cells.append(cells)
+            all_heat.append(heat)
+            statuses.append(dict(example=example["slug"], status="available",
+                                 real_parent_cells=int((cells.arm == "observed").sum()),
+                                 generated_parent_cells=int((cells.arm != "observed").sum())))
+        except ValueError as exc:
+            if "missing mandatory marker" not in str(exc) and "fewer than 16 real parent" not in str(exc):
+                raise
+            statuses.append(dict(example=example["slug"], status="unavailable", reason=str(exc)))
+    cells = pd.concat(all_cells, ignore_index=True) if all_cells else pd.DataFrame()
+    heat = pd.concat(all_heat, ignore_index=True) if all_heat else pd.DataFrame()
+    (out / "source_data").mkdir(parents=True, exist_ok=True)
+    (out / "reports").mkdir(parents=True, exist_ok=True)
+    cells.to_csv(out / "source_data/rare_visual_cells.csv", index=False)
+    heat.to_csv(out / "source_data/rare_visual_heatmap.csv", index=False)
+    pd.DataFrame(choices).drop_duplicates().to_csv(out / "source_data/rare_visual_donor_draws.csv", index=False)
+    _plot_panels(cells, heat, statuses, out)
+    visual_status = "complete" if any(s["status"] == "available" for s in statuses) else "unavailable"
+    report = {"schema": "pbisc.figure5.marker-visuals.v1", "status": visual_status,
+              "evidence_tier": "strict", "projection": "PCA and 15-neighbor UMAP fit observed marker counts only; generated transform frozen",
+              "projection_seed": SEED, "donor_draw_seed": SEED,
+              "projection_space": "measured_marker_counts_illustration_not_numeric_score",
+              "visual_cells_per_sample_cap": cells_per_sample,
+              "common_analysis_cell_budget": int(units[0]["cell_budget"]),
+              "common_depth_target": float(units[0]["depth_target"]),
+              "examples": statuses, "all_draw_numeric_metrics": "source_data/rare_summary.csv"}
+    (out / "reports/rare_visual_provenance.json").write_text(json.dumps(report, indent=2) + "\n")
+    if require_complete:
+        prior_path = out / "reports/rare_provenance.json"
+        prior = json.loads(prior_path.read_text())
+        prior["visuals"] = {"status": visual_status, "provenance": "reports/rare_visual_provenance.json",
+                            "figure": "figures/fig5_rare_visuals_strict.pdf"}
+        prior_path.write_text(json.dumps(prior, indent=2) + "\n")
+    return report
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--manifest-dir", type=Path, required=True)
+    ap.add_argument("--output", type=Path, default=HERE)
+    ap.add_argument("--cells-per-sample", type=int, default=100)
+    args = ap.parse_args()
+    units = read_units(args.manifest_dir)
+    print(json.dumps(build_visuals(units, args.output, cells_per_sample=args.cells_per_sample)))
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/export_scsemi_strict.py

@@ -0,0 +1,198 @@
+# Adapted from paired_finetune_intradataset_20260927/scsemi/tools/export_npz.py.
+# Strict support extension; legacy exporter remains unchanged.
+#!/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 strict_arm_metadata(man: dict, support: dict) -> dict:
+    if man.get("mode") != "strict" or man.get("dataset") != support["cohort"]:
+        raise ValueError("strict export requires strict dataset inputs")
+    if (man.get("support_sha256") != support["sha256"] or
+            [r["sample_id"] for r in man["representatives"]] != support["train_sample_ids"] or
+            man["train_donors"] != support["train_donor_ids"] or
+            man["target_order_test_samples"] != support["test_sample_ids"]):
+        raise ValueError("export support or reference budget mismatch")
+    return {"arm": "scsemi", "support_sha256": support["sha256"], "cohort": support["cohort"],
+            "unit": support["unit"], "n_pairs": support["n_pairs"],
+            "train_sample_ids": support["train_sample_ids"], "train_donor_ids": support["train_donor_ids"]}
+
+
+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)")
+    ap.add_argument("--support-manifest", type=Path, required=True)
+    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)")
+    from run_scsemi_strict import validate_strict_inputs
+    support = validate_strict_inputs(a.support_manifest, work, phase="export", reuse_from=None)
+    strict_meta = strict_arm_metadata(man, support)
+    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
+    arm = strict_meta["arm"]
+    meta = {"method": "scSemiProfiler", "arm": arm,
+            "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)}
+    meta["strict_support"] = strict_meta
+    if "budget" in man:
+        meta["budget"] = man["budget"]
+    if "reuse" in run:        # pretraining / hvset reused from another run (run_scsemi_paired.py --reuse-from)
+        meta["reuse"] = run["reuse"]
+    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,
+               "strict_support": strict_meta, "inputs_manifest_sha256": sha(work / "inputs/inputs_manifest.json"),
+               "inputs_manifest_path": str(work / "inputs/inputs_manifest.json")}
+    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/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/figure2_panels.py

@@ -0,0 +1,163 @@
+"""Figure 2: native pseudobulk design and separately evaluated real-bulk adaptation."""
+from pathlib import Path
+import json
+import hashlib
+import csv
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+OLD = ROOT.parent / 'paired_finetune_intradataset_20260927'
+RANK_ARMS = (
+    ('Full FT', 'real_full__raw', 'real_full', 'pooled'),
+    ('LoRA r=4', 'lora_r4__raw', 'lora_r4', 'lora_rank_20261001/pooled'),
+    ('LoRA r=16', 'real_lora__raw', 'real_lora', 'pooled'),
+    ('LoRA r=64', 'lora_r64__raw', 'lora_r64', 'lora_rank_20261001/pooled'),
+)
+
+def sha(path):
+    return hashlib.file_digest(Path(path).open('rb'), 'sha256').hexdigest()
+
+def read(path):
+    return json.loads(Path(path).read_text())
+
+def historical_rank_rows():
+    """All four arms trained on the same real-bulk folds and validation donors."""
+    rows, proofs = [], []
+    reference = None
+    for label, arm, run_name, score_rel in RANK_ARMS:
+        score = OLD / 'scores/immicro' / score_rel / 'summary.json'
+        summary = read(score)
+        signature = (summary['donors'], summary['reference']['reference_sha256'],
+                     summary['reference']['features_sha256'])
+        if reference is None:
+            reference = signature
+        if signature != reference:
+            raise ValueError('historical rank/full scoring references or held-out donors differ')
+        params = set()
+        run_proofs = []
+        for fold in range(5):
+            source = OLD / 'runs/immicro' / f'fold{fold}' / run_name / 'RUN.json'
+            record = read(source)
+            baseline = read(OLD / 'runs/immicro' / f'fold{fold}/real_full/RUN.json')
+            if not record['condition_npz'].endswith('/conditions_raw_fixed.npz'):
+                raise ValueError('Figure 2 rank selection requires real-bulk adaptation')
+            for key in ('condition_npz_sha256', 'source_checkpoint_sha256'):
+                if record[key] != baseline[key]:
+                    raise ValueError(f'rank/full {key} differs')
+            for key in ('train_rows', 'inner_val_rows', 'test_rows_never_loaded_for_training'):
+                if set(record[key]) != set(baseline[key]):
+                    raise ValueError(f'rank/full {key} differs in fold {fold}')
+            params.add(record['trainable']['n_trainable'])
+            run_proofs.append({'fold': fold, 'source': str(source), 'sha256': sha(source),
+                               'train_samples': len(record['train_rows']),
+                               'validation_samples': len(record['inner_val_rows']),
+                               'test_samples': len(record['test_rows_never_loaded_for_training'])})
+        if len(params) != 1:
+            raise ValueError('parameter count differs across historical folds')
+        metric = summary['per_arm'][arm]
+        rows.append({'design': 'historical_real_bulk_5fold_pooled107', 'arm': arm,
+                     'label': label, 'precision': metric['precision_coverage']['precision'],
+                     'coverage': metric['precision_coverage']['coverage'],
+                     'comp_l1': metric['composition']['l1_mean'], 'trainable_parameters': params.pop(),
+                     'source': str(score), 'source_sha256': sha(score)})
+        proofs.append({'arm': arm, 'folds': run_proofs})
+    return rows, proofs
+
+def strict_curve_rows(units):
+    rows = []
+    for unit in units:
+        support = unit['support']
+        for arm in ('lora', 'pairedcal', 'scsemi', 'raw', 'refcal'):
+            metric = unit['summary']['per_arm'][arm]
+            pc = metric['precision_coverage']
+            rows.append({'design': 'strict_exact_n', 'fold': support['unit'].split('_')[0],
+                         'n_pairs': support['n_pairs'], 'target_pairs_used': 0 if arm in ('raw','refcal') else support['n_pairs'],
+                         'arm': arm, 'precision': pc['precision'], 'coverage': pc['coverage'],
+                         'comp_l1': metric['composition']['l1_mean'],
+                         'support_sha256': support['sha256'], 'summary': unit['summary_path'],
+                         'summary_sha256': sha(unit['summary_path'])})
+    return rows
+
+def render(pretrain, strict, missing, provenance, api):
+    plt, colors = api.plt, api.COLORS
+    fig, axs = plt.subplots(3, 3, figsize=(7.09, 7.45), layout='constrained')
+    for ax, family, title in ((axs[0,0], 'architecture_floor1pct', 'A  Architecture · 1% floor'),
+                              (axs[0,1], 'panel_floor0.1pct', 'B  Gene panel · 0.1% floor')):
+        for j, row in enumerate(r for r in pretrain if r['family'] == family):
+            ax.scatter(float(row['coverage']), float(row['precision']), s=23,
+                       color=colors['real_R2_independent'] if row['method']=='real_R2_independent' else f'C{j%8}')
+            ax.annotate(row['method'].replace('real_R2_independent','Real R2'),
+                        (float(row['coverage']),float(row['precision'])),xytext=(2,3),textcoords='offset points',fontsize=5.3)
+        ax.set(title=title, xlabel='Coverage', ylabel='Precision'); ax.grid(alpha=.15)
+    composition = ROOT/'source_data/ablation_pretrain_composition.csv'
+    ax=axs[0,2]
+    if composition.is_file():
+        receipt=read(ROOT/'source_data/ablation_pretrain_composition_receipt.json')
+        if receipt.get('schema')!='pbisc.fig2.ablation-composition.v1' or receipt.get('status')!='complete':
+            raise ValueError('pretraining composition is not complete')
+        expected=receipt['outputs']['ablation_pretrain_composition.csv']
+        if expected['path']!=str(composition) or expected['sha256']!=sha(composition):
+            raise ValueError('pretraining composition source hash differs')
+        for key in ('pc_receipt','pc_csv'):
+            entry=receipt['inputs'][key]
+            if sha(entry['path'])!=entry['sha256']:
+                raise ValueError('composition and P/C no longer share the same rescore inputs')
+        rr=api.records(composition)
+        keys=list(dict.fromkeys((r['family'],r['method']) for r in rr))
+        for j,(family,method) in enumerate(keys):
+            vals=[float(r['comp_l1']) for r in rr if r['family']==family and r['method']==method]
+            ax.scatter(np.full(len(vals),j),vals,s=3,alpha=.2,color='C0' if family.startswith('architecture') else 'C1')
+            ax.plot(j,np.mean(vals),'_',color='black',markersize=8)
+        ax.set_xticks(range(len(keys)),[m.replace('real_R2_independent','Real R2') for _,m in keys],rotation=90,fontsize=4.7)
+        ax.set(title='C  Composition · separate sweeps',ylabel='Donor composition L1')
+    else:
+        api.pending(ax,'C  Composition','Common-reference native pseudobulk composition rescoring pending.')
+    hist,proof=historical_rank_rows()
+    for j,r in enumerate(hist):
+        axs[1,0].scatter(r['coverage'],r['precision'],s=25,color=f'C{j}')
+        axs[1,0].annotate(r['label'],(r['coverage'],r['precision']),xytext=(2,3),textcoords='offset points',fontsize=5.3)
+        axs[1,1].bar(j,r['comp_l1'],color=f'C{j}')
+        axs[1,2].bar(j,r['trainable_parameters'],color=f'C{j}')
+    axs[1,0].set(title='D  Real-bulk 5-fold quality',xlabel='Coverage',ylabel='Precision')
+    for ax,title,label in ((axs[1,1],'E  Same folds · composition','Mean donor L1'),
+                            (axs[1,2],'F  Adapted parameters','Trainable parameters')):
+        ax.set(title=title,ylabel=label)
+        ax.set_xticks(range(4),[r['label'] for r in hist],rotation=40,ha='right',fontsize=5.5)
+    axs[1,2].set_yscale('log')
+    rows=strict_curve_rows(strict)
+    labels={'lora':'LoRA r=16','pairedcal':'Same-n calibration','scsemi':'scSemiProfiler','raw':'Raw (0 pairs)','refcal':'External ref-cal (0 pairs)'}
+    for ax,key,title in zip(axs[2],('precision','coverage','comp_l1'),('G  Strict-n precision','H  Strict-n coverage','I  Strict-n composition')):
+        if not rows:
+            api.pending(ax,title,'Five outer folds × n=5, 10, 20, 40 pending.'); continue
+        for arm in ('lora','pairedcal','scsemi','raw','refcal'):
+            rr=[r for r in rows if r['arm']==arm]
+            if arm in ('raw','refcal'):
+                by_fold={r['fold']:float(r[key]) for r in rr}
+                if any(abs(float(r[key])-by_fold[r['fold']])>1e-10 for r in rr):
+                    raise ValueError('zero-pair baseline differs across n within a fixed outer fold')
+                ax.axhline(np.mean(list(by_fold.values())),ls='--',color=colors[arm],label=labels[arm],lw=.9)
+            else:
+                ns=sorted({r['n_pairs'] for r in rr})
+                means=[]
+                for n in ns:
+                    vv=[float(r[key]) for r in rr if r['n_pairs']==n];means.append(np.mean(vv))
+                    ax.scatter([n]*len(vv),vv,s=7,alpha=.3,color=colors[arm])
+                ax.plot(ns,means,'o-',markersize=3,lw=.9,color=colors[arm],label=labels[arm])
+        ax.set(title=title,xlabel='Exact paired samples',ylabel='Composition L1' if key=='comp_l1' else key.capitalize())
+        ax.set_xticks([5,10,20,40]);ax.grid(alpha=.1)
+    if rows: axs[2,1].legend(fontsize=4.8,loc='best',frameon=False)
+    for ax in axs.flat:
+        ax.title.set_fontsize(7)
+    if len(strict) < 20:
+        fig.suptitle(f'Review preview · strict healthy units {len(strict)}/20; remaining results pending',fontsize=8,color='#963f29')
+    api.save(fig,'fig2_ablation_and_support')
+    api.write_csv(ROOT/'source_data/fig2_historical_rank_full.csv',hist,list(hist[0]))
+    (ROOT/'source_data/fig2_historical_rank_full_provenance.json').write_text(json.dumps({'schema':'pbisc.fig2.rank-realbulk.v1','selection':'quality-size balance; not best on every metric','arms':proof},indent=2)+'\n')
+    api.write_csv(ROOT/'source_data/fig2_strict_curve.csv',rows,
+                  ['design','fold','n_pairs','target_pairs_used','arm','precision','coverage','comp_l1','support_sha256','summary','summary_sha256'])
+    return {'strict_complete_units':len(strict),'strict_expected_units':20,'strict_missing':missing,
+            'historical_design':'historical_real_bulk_5fold_pooled107','historical_sources':hist,
+            'pretrain_composition_ready':composition.is_file(),
+            'pretrain_source':str(ROOT/'source_data/ablation_pretrain_pc.csv'),
+            'pretrain_source_sha256':sha(ROOT/'source_data/ablation_pretrain_pc.csv'),
+            'pretrain_receipt_sha256':sha(ROOT/'source_data/ablation_pretrain_pc_receipt.json')}