Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261013T144247Z-f01-trunk4x-campaign-launch/diffusion/dataset/server_1/model8/plans/f01_trunk4x_complete_20261013/tools/bulk_compact.py

@@ -0,0 +1,17 @@
+"""Frozen annotation and all6k pseudobulks for new bulk-only generations."""
+from pathlib import Path
+import sys,os,json
+import numpy as np
+P=Path(__file__).resolve().parents[1];M=P.parents[1];F=M/'plans/paired_finetune_intradataset_20260927';B=M/'plans/bulkonly_lora5_20261006'
+sys.path[:0]=[str(B/'tools'),str(F/'tools')]
+import common as C
+import ft_common as FCommon
+cohort,draw,part=sys.argv[1:];folder=P/f'payload/bulkonly/{cohort}/draw{draw}/part{part}';path=folder/'generated.npz'
+rec=json.loads(path.with_suffix('.log').read_text());assert C.sha(path)==rec['output_sha256'];ps=C.panel_setup(cohort)
+with np.load(path,allow_pickle=False) as z:
+ assert np.array_equal(z['gene_ids'].astype(str),ps['panel']);samples=z['sample_ids'].astype(str)[z['bulk_index'].astype(int)]
+ X=FCommon.PR.poisson_integerise(np.ascontiguousarray(z['generated_counts'],dtype=np.float32),seed=FCommon.POISSON_SEED,chunk_rows=4096).tocsr()
+ref,man=FCommon.load_reference(FCommon.CACHE_ROOT/cohort);pos={g:i for i,g in enumerate(ps['panel'])};qi=np.asarray([pos[g] for g in ref['query_ids'].astype(str)])
+lab,info=FCommon.run_annotator(X[:,qi],ref['query_ids'].astype(str),samples,work=folder/'annotation',method='trunk4x_bulkonly',spec=FCommon.DATASETS[cohort],split='bulkonly',threads=4,annot=FCommon.annotator_run(),expected_zero_pad=man['gene_sets']['model_genes_missing_from_query'],source_note={'source':str(path),'source_sha256':rec['output_sha256'],'readout':'poisson','seed':FCommon.POISSON_SEED})
+result=C.write_compact(folder/'compact',X,samples,lab,ps,{'dataset':cohort,'draw':int(draw),'part':int(part),'source':str(path),'source_sha256':rec['output_sha256'],'annotation':info,'readout':'whole part NPZ, native saved Poisson seed','clinical_metadata':str(B/f'analysis/features/{cohort}/meta.csv')})
+(folder/'COMPACT.json').write_text(json.dumps(result,indent=2,default=str)+'\n')

paper-releases/pbisc-diffusion/updates/20261013T144247Z-f01-trunk4x-campaign-launch/diffusion/dataset/server_1/model8/plans/f01_trunk4x_complete_20261013/tools/downstream.py

@@ -0,0 +1,91 @@
+"""Execute the sealed same-gene-context matrix. No unchanged baseline training."""
+from pathlib import Path
+from datetime import datetime,timezone
+import json,os,sys,shutil,subprocess
+P=Path(__file__).resolve().parents[1];M=P.parents[1];S=M/'plans/paper_figures_strictpairs_20261012';F=M/'plans/paired_finetune_intradataset_20260927'
+sys.path.insert(0,str(S/'tools'))
+from runtime import Runtime,sha256,atomic_json
+PY='/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python';CPU='/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python'
+def status(phase,**kw):atomic_json(P/'DOWNSTREAM_STATUS.json',{'phase':phase,'at':datetime.now(timezone.utc).isoformat(),**kw})
+def safe_storage():
+ contract=json.loads((P/'CONTRACT.json').read_text())
+ for source,digest in {**contract['sources'],**contract['configs']}.items():assert sha256(Path(source))==digest,source
+ for source,digest in json.loads((P/'WORKFLOW_SEAL.json').read_text())['files'].items():assert sha256(Path(source))==digest,source
+ assert os.path.ismount(P/'payload'),'NAS unmounted; stop before falling back to local storage'
+ v=os.statvfs(P/'payload');assert v.f_bavail*v.f_frsize>120*2**30,'NAS free space below reserve'
+def main():
+ matrix=json.loads((P/'MATRIX.json').read_text());verified=json.loads((P/'PRETRAIN_VERIFIED.json').read_text());safe_storage()
+ base=Path(verified['checkpoint']);assert sha256(base)==verified['checkpoint_sha256']
+ cache=P/'base_cache';cache.mkdir(exist_ok=True);local=cache/'checkpoint_epoch_016.pt'
+ if not local.exists():shutil.copyfile(base,local)
+ assert sha256(local)==verified['checkpoint_sha256'];base=local
+ rt=Runtime(P/'payload/runtime');parent_sha=verified['checkpoint_sha256']
+ def execute(tag,args,resource='cpu',inputs=(),outputs=(),mem=32):
+  safe_storage();rt.execute(tag,args,resource=resource,memory_gib=mem,threads=4,inputs=list(inputs),outputs=list(outputs))
+ def sample(tag,cp,condition,out,seed):
+  out.parent.mkdir(parents=True,exist_ok=True)
+  execute(tag,[PY,'-u',str(S/'tools/sample_one.py'),'--checkpoint',str(cp),'--checkpoint-sha',sha256(cp),'--condition',str(condition),'--output',str(out),'--seed',str(seed)],'gpu',[cp,condition,S/'tools/sample_one.py'],[out,out.with_suffix('.log')],48)
+ # Final E16 fixed before downstream outcomes. The SLE builder uses a namespace-local compatibility tag.
+ for row in matrix['sle']:
+  folder=P/f"payload/sle/seed{row['seed_index']}";g=folder/'generated_f016k_e16.npz';status('sle',seed=row['seed'])
+  sample('sle-'+str(row['seed_index']),base,M/'artifacts/gse135779_scsemi_split_target42_20260913/donor_conditions.npz',g,row['seed'])
+  execute('sle-score-'+str(row['seed_index']),[CPU,str(P/'tools/score_sle.py'),str(row['seed_index'])],inputs=[g,P/'tools/score_sle.py'],outputs=[folder/'DONE.json'])
+ # Unadapted/reference-calibrated outputs depend on the new pretrained checkpoint, so cannot reuse x1 cells.
+ for cohort in matrix['global_cohorts']:
+  for arm in ['raw','refcal']:
+   c=S/f'data/external_refcal/{cohort}/conditions_{arm}.npz';g=P/f'payload/global/{cohort}/{arm}.npz'
+   status('global_generation',cohort=cohort,arm=arm);sample('global-'+cohort+'-'+arm,base,c,g,20260928)
+ jobs=matrix['paired_jobs'];byid={j['id']:j for j in jobs}
+ # Canonical strict40 first, then historical full/rank CV, then additional legacy-donor supports.
+ for index,j in enumerate(jobs):
+  tag=j['id'].replace('/','-');out=Path(j['output']);out.mkdir(parents=True,exist_ok=True);status('paired',job=j['id'],index=index,total=len(jobs))
+  if j.get('adapter_alias'):
+   alias=byid[j['adapter_alias']];run=Path(alias['output'])/'run'
+   r=json.loads((run/'RUN.json').read_text());assert set(r['train_rows'])==set(j['train_samples']) and set(r['test_rows_never_loaded_for_training'])==set(j['test_samples'])
+   atomic_json(out/'ADAPTER_ALIAS.json',{'source_run':str(run),'checkpoint_sha256':r['checkpoint_sha256'],'reason':'identical support/test, seed, fixed3000 schedule and exact same f01x4 parent; do not train twice'})
+  else:
+   run=out/'run';ds=F/f"data/{j['cohort']}"
+   if j['family']!='strict':
+    execute(tag+'-isolate',[CPU,str(P/'tools/prepare_legacy.py'),j['id']],inputs=[P/'MATRIX.json',ds/'cells_panel6k.npz',ds/'folds.csv',P/'tools/prepare_legacy.py'],outputs=[out/'input'/j['cohort']/'ISOLATION.json'])
+    ds=out/'input'/j['cohort']
+   cmd=[PY,'-u',str(F/'tools/ft_sdd.py'),'--checkpoint',str(base),'--checkpoint-sha',parent_sha,'--dataset-dir',str(ds),'--condition-npz',j['condition'],'--fold',str(j.get('fold',0)),'--mode',j['mode'],'--lora-rank',str(j['rank']),'--lora-alpha',str(j['alpha']),'--lr',str(j['lr']),'--warmup',str(j['warmup']),'--batch-size',str(j['batch_size']),'--ema-decay',str(j['ema_decay']),'--seed',str(j['seed']),'--max-cuda-gib','24','--min-system-gib','32','--out-dir',str(run)]
+   if j['fixed_steps']:cmd+=['--fixed-steps',str(j['fixed_steps'])]
+   if j['family']=='strict':cmd+=['--support-manifest',j['support_path']]
+   elif j['family']=='legacy5':cmd+=['--train-donors-file',str(ds/'train_donors.txt')]
+   else:cmd+=['--max-steps',str(j['max_steps']),'--eval-every',str(j['eval_every']),'--patience',str(j['patience'])]
+   execute(tag+'-train',cmd,'gpu',[base,P/'MATRIX.json',Path(j['condition']),ds/'cells_panel6k.npz',F/'tools/ft_sdd.py'],[run/'RUN.json',run/'checkpoint_ft.pt'],64)
+  r=json.loads((run/'RUN.json').read_text());assert r['source_checkpoint_sha256']==parent_sha;assert set(r['train_rows'])==set(j['train_samples']);assert set(r['inner_val_rows'])==set(j['validation_samples']);assert set(r['test_rows_never_loaded_for_training'])==set(j['test_samples'])
+  if j.get('generation_alias'):
+   alias=byid[j['generation_alias']]
+   for ext in ['.npz','.log']:
+    dst=out/('generated'+ext)
+    if not dst.exists():dst.symlink_to(Path(alias['output'])/('generated'+ext))
+   atomic_json(out/'GENERATION_ALIAS.json',{'source':alias['output'],'proof':str(P/'GENERATION_REUSE_PROOF.json')})
+  else:sample(tag+'-generate',run/'checkpoint_ft.pt',Path(j['test_condition']),out/'generated.npz',j['sampling_seed'])
+  if j['family']=='strict':sample(tag+'-pairedcal',base,Path(j['cal_condition']),out/'pairedcal.npz',20260928)
+  if j.get('generation_alias'):
+   dest=out/'evaluation'
+   if not dest.exists():dest.symlink_to(Path(byid[j['generation_alias']]['output'])/'evaluation',target_is_directory=True)
+   atomic_json(out/'EVALUATION_ALIAS.json',{'source':str(dest.resolve()),'reason':'Same generated cells, test donors and scoring contract; reuse exact strict Sepsis metrics.'})
+  else:execute(tag+'-score',[CPU,str(P/'tools/score_paired.py'),j['id']],inputs=[out/'generated.npz',P/'MATRIX.json',P/'tools/score_paired.py'],outputs=[out/'evaluation/DONE.json'])
+ # CV metrics must be scored on the same pooled held-out donors, not averaged fold P/C.
+ execute('pool-cv-and-score',[CPU,str(P/'tools/pool_cv.py')],inputs=[P/'MATRIX.json',P/'tools/pool_cv.py'],outputs=[P/'payload/pooled/DONE.json'])
+ # Published bulk-only condition files are reused; matching legacy-donor adaptation is explicit.
+ for cohort in matrix['bulkonly_cohorts']:
+  B=M/'plans/bulkonly_lora5_20261006/data'/cohort
+  conditions=sorted(B.glob('bulkonly_raw_part*.npz')) or [B/'bulkonly_raw.npz']
+  for draw in range(5):
+   j=byid[f'legacy5/{cohort}/draw{draw}'];source=byid[j['adapter_alias']] if j.get('adapter_alias') else j;cp=Path(source['output'])/'run/checkpoint_ft.pt'
+   for part,condition in enumerate(conditions):
+    dest=P/f'payload/bulkonly/{cohort}/draw{draw}/part{part}/generated.npz';status('bulkonly',cohort=cohort,draw=draw,part=part)
+    sample(f'bulk-{cohort}-{draw}-{part}',cp,condition,dest,20260927)
+    execute(f'bulk-compact-{cohort}-{draw}-{part}',[CPU,str(P/'tools/bulk_compact.py'),cohort,str(draw),str(part)],inputs=[dest,P/'tools/bulk_compact.py'],outputs=[dest.parent/'COMPACT.json'])
+ execute('assemble-comparisons',[CPU,str(P/'tools/finalize.py')],inputs=[P/'MATRIX.json',P/'tools/finalize.py'],outputs=[P/'RESULTS_STATUS.json'])
+ result=json.loads((P/'RESULTS_STATUS.json').read_text());status(result['phase'],result=str(P/'RESULTS_STATUS.json'))
+ try:
+  execute('archive-completed',["/home/sj_server_1/miniforge3/bin/python",str(P/'tools/archive_completed.py')],inputs=[P/'RESULTS_STATUS.json',P/'tools/archive_completed.py'],outputs=[P/'FINAL_ARCHIVE.json'],mem=4)
+ except Exception as e:
+  status('data_complete_archive_pending',result=str(P/'RESULTS_STATUS.json'),error=str(e))
+if __name__=='__main__':
+ try:main()
+ except BaseException as e:status('stopped_needs_inspection',error=str(e));raise

paper-releases/pbisc-diffusion/updates/20261013T144247Z-f01-trunk4x-campaign-launch/diffusion/dataset/server_1/model8/plans/f01_trunk4x_complete_20261013/tools/finalize.py

@@ -0,0 +1,90 @@
+"""Collect paired comparisons without regenerating x1/comparator outputs."""
+from pathlib import Path
+import json,sys,subprocess,shlex
+import numpy as np
+import pandas as pd
+P=Path(__file__).resolve().parents[1];M=P.parents[1];F=M/'plans/paired_finetune_intradataset_20260927';S=M/'plans/paper_figures_strictpairs_20261012';sys.path.insert(0,str(S/'tools'))
+from donor_statistics import paired_donor_bootstrap
+from runtime import sha256
+jobs=json.loads((P/'MATRIX.json').read_text())['paired_jobs'];rows=[];pending=[];long=[]
+def obtain(path):
+ if path.is_file():return path
+ out=P/'payload/baseline_metadata'/path.relative_to(M);out.parent.mkdir(parents=True,exist_ok=True)
+ result=subprocess.run(['ssh','-o','BatchMode=yes','-o','ConnectTimeout=10','spark-0110','cat '+shlex.quote(str(path))],capture_output=True)
+ if result.returncode:return None
+ out.write_bytes(result.stdout);return out
+
+def compatible(a,b):
+ return a['reference']['reference_sha256']==b['reference']['reference_sha256'] and set(a['donors'])==set(b['donors']) and a['contrast_definition']==b['contrast_definition'] and a.get('gene_exclusion')==b.get('gene_exclusion')
+def record(j,arm,v,source):
+ c=v.get('contrast',{}).get('mean_cp10k',{})
+ rows.append({'job':j['id'],'family':j['family'],'budget':json.loads(Path(j['support_path']).read_text())['n_pairs'] if j.get('support_path') else None,'cohort':j['cohort'],'arm':arm,'logfc_r':c.get('mean_r_generated'),'partial_r':c.get('mean_partial_r'),'deg_overlap':v.get('deg_top50',{}).get('sum'),'composition_l1':v['composition']['l1_mean'],'precision':v['precision_coverage']['precision'],'coverage':v['precision_coverage']['coverage'],'expression_r':v['pseudobulk']['r_median'],'source':str(source),'source_sha256':sha256(source)})
+for j in jobs:
+ p=Path(j['output'])/'evaluation/score/summary.json';s=json.loads(p.read_text());record(j,'trunk4x',s['per_arm']['trunk4x'],p)
+ if not j.get('baseline_score'):continue
+ bp=obtain(Path(j['baseline_score']))
+ if bp is None:pending.append({'job':j['id'],'reason':'Existing x1 score not yet available','path':j['baseline_score']});continue
+ b=json.loads(bp.read_text())
+ if not compatible(s,b):pending.append({'job':j['id'],'reason':'Baseline score contract differs; reuse generated output for a matched CPU rescore, never retrain','path':str(bp)});continue
+ candidates=['lora','lora5','real_lora__raw']
+ key=next((x for x in candidates if x in b['per_arm']),None)
+ if key is None:pending.append({'job':j['id'],'reason':'Baseline arm mapping unresolved'});continue
+ record(j,'current_x1',b['per_arm'][key],bp)
+ if 'scsemi' in b['per_arm']:record(j,'scsemi',b['per_arm']['scsemi'],bp)
+ if j['family']=='strict':
+  sup=json.loads(Path(j['support_path']).read_text());budget=sup['n_pairs'];mapping=dict(zip(sup['test_sample_ids'],sup['test_donor_ids']))
+  oldcsv=obtain(Path(j['baseline_score']).parent/'per_donor.csv')
+  if oldcsv is None:continue
+  for path,oldarm,newarm in [(p.parent/'per_donor.csv','trunk4x','trunk4x'),(oldcsv,key,'current_x1')]:
+   d=pd.read_csv(path);d=d[d.arm==oldarm].copy();d['arm']=newarm;d['draw']=sup['unit'];d['sample_id']=d['donor'].astype(str);d['donor_id']=d.sample_id.map(mapping);assert d.donor_id.notna().all();d['cohort']=j['cohort'];d['budget']=budget;long.append(d)
+# Pooled CV is compared to an exactly matching original pooled arm, never a mean of fold-level P/C.
+for cohort,arm in sorted({(j['cohort'],j['old_arm']) for j in jobs if j['family']=='cv'}):
+ p=P/f'payload/pooled/{cohort}/{arm}/score/summary.json';s=json.loads(p.read_text());j={'id':f'pooled/{cohort}/{arm}','family':'pooled_cv','cohort':cohort};record(j,'trunk4x',s['per_arm']['trunk4x'],p)
+ found=False
+ for bp in (F/f'scores/{cohort}').glob('**/summary.json'):
+  if 'pooled' not in str(bp):continue
+  try:b=json.loads(bp.read_text())
+  except ValueError:continue
+  key=arm+'__raw'
+  if key in b.get('per_arm',{}) and compatible(s,b):record(j,'current_x1',b['per_arm'][key],bp);found=True;break
+ if not found:pending.append({'job':j['id'],'reason':'Matching pooled x1 summary not located; preserve new pooled output and require source-bound comparison'})
+D=P/'comparison';D.mkdir(exist_ok=True);table=pd.DataFrame(rows);table.to_csv(D/'metrics.csv',index=False)
+ci=[]
+if long:
+ long=pd.concat(long,ignore_index=True);long.to_csv(D/'donor_metrics.csv',index=False)
+ for (cohort,budget),part in long.groupby(['cohort','budget']):
+  for metric in ['comp_l1','precision','coverage','pb_r']:
+   c=paired_donor_bootstrap(part.rename(columns={metric:'value'}),'trunk4x','current_x1',n_boot=2000,seed=20261013);c.update(cohort=cohort,budget=int(budget),metric=metric);ci.append(c)
+pd.DataFrame(ci).to_csv(D/'paired_donor_ci.csv',index=False)
+# Keep measured cost and every broad cell type, including adverse results.
+cost=[]
+for j in jobs:
+ if j.get('adapter_alias'):continue
+ rp=Path(j['output'])/'run/RUN.json';r=json.loads(rp.read_text())
+ cost.append({'job':j['id'],'cohort':j['cohort'],'family':j['family'],'mode':r['mode'],'steps_run':r['steps_run'],'selected_step':r['selected_step'],'trainable_parameters':r['trainable']['n_trainable'],'base_parameters':r['trainable']['n_total_base'],'wall_seconds':r['wall_seconds'],'source':str(rp),'timing_scope':'observed run walltime, not a controlled speed microbenchmark'})
+pd.DataFrame(cost).to_csv(D/'adaptation_cost.csv',index=False)
+ct=[]
+if isinstance(long,pd.DataFrame):
+ for (cohort,budget,arm),q in long.groupby(['cohort','budget','arm']):
+  if cohort!='immicro':continue
+  for typ in ['T cell','B cell','Monocyte','NK cell','DC','Other']:
+   a=q['obs_'+typ].to_numpy();b=q['gen_'+typ].to_numpy()
+   ct.append({'budget':int(budget),'arm':arm,'cell_type':typ,'n_donors':q.donor_id.nunique(),'pearson_r':float(np.corrcoef(a,b)[0,1]) if np.std(a)>0 and np.std(b)>0 else None,'mae_percentage_points':float(np.abs(a-b).mean()*100)})
+pd.DataFrame(ct).to_csv(D/'healthy_all_celltypes.csv',index=False)
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.family':'sans-serif','font.sans-serif':['Arial','Liberation Sans'],'font.size':11,'axes.spines.top':False,'axes.spines.right':False,'pdf.fonttype':42})
+colors={'trunk4x':'#168FE5','current_x1':'#0D6EA8','scsemi':'#83C6A8'}
+for (cohort,budget),t in table[table.family=='strict'].groupby(['cohort','budget']):
+ fig,axes=plt.subplots(2,3,figsize=(12.3,6.3))
+ for ax,col in zip(axes.flat,['logfc_r','partial_r','deg_overlap','composition_l1','precision','coverage']):
+  for k,(arm,d) in enumerate(t.groupby('arm',sort=True)):
+   vals=pd.to_numeric(d[col],errors='coerce').dropna().to_numpy();ax.scatter(np.full(len(vals),k),vals,color=colors[arm],s=20,alpha=.6)
+   if len(vals):ax.plot([k-.17,k+.17],[vals.mean()]*2,color=colors[arm],lw=3)
+  ax.set_xticks(range(t.arm.nunique()),sorted(t.arm.unique()),rotation=15,ha='right');ax.set_title(col)
+ fig.suptitle(cohort+f' · {int(budget)} support pairs · exact-panel comparison');fig.text(.5,.015,'Support/fold points are descriptive, not independent replicates. Each panel holds the support budget fixed; use paired donor CI tables for uncertainty.',ha='center',fontsize=8);fig.tight_layout(rect=(0,.05,1,.95))
+ for ext in ['png','pdf','svg']:fig.savefig(D/f'{cohort}_n{int(budget)}.{ext}',dpi=180)
+ plt.close(fig)
+(P/'PENDING_EVIDENCE.json').write_text(json.dumps({'comparison_gaps':pending,'rare_identity':'Author fine-cluster annotation/treatment-time alignment required; new marker caches are not proof of population recovery.','bulkonly_reproduction':'New all6k celltype pseudobulks/markers ready; exact original-paper clinical contrast and paired-reference validation remain required.','legacy_K4000':'Not silently substituted with K1000 adapters. A separate matched training/condition contract is needed before that sensitivity is executed.'},indent=2)+'\n')
+(P/'RESULTS_STATUS.json').write_text(json.dumps({'phase':'data_complete_with_review_gates','paired_jobs':len(jobs),'new_adapters':sum(not j.get('adapter_alias') for j in jobs),'comparison_rows':len(rows),'unresolved_comparisons':len(pending),'tables':str(D),'manuscript_or_deck_overwritten':False,'biological_claims_confirmed':False},indent=2)+'\n')

paper-releases/pbisc-diffusion/updates/20261013T144247Z-f01-trunk4x-campaign-launch/diffusion/dataset/server_1/model8/plans/f01_trunk4x_complete_20261013/tools/pool_cv.py

@@ -0,0 +1,23 @@
+"""Reuse exact historical fold-pooling arithmetic within a new isolated namespace."""
+from pathlib import Path
+import os,sys,json
+P=Path(__file__).resolve().parents[1];M=P.parents[1];F=M/'plans/paired_finetune_intradataset_20260927';sys.path.insert(0,str(F/'tools'))
+import pool_folds as PO
+import score_ft as FT
+jobs=json.loads((P/'MATRIX.json').read_text())['paired_jobs'];workspace=P/'payload/pool_workspace';PO.TASK=workspace
+pairs=sorted({(j['cohort'],j['old_arm']) for j in jobs if j['family']=='cv'})
+groups={'ye2026_sepsis':('adult_sepsis,ped_sepsis','adult_HC,adult_ICU_ctrl,ped_HC,ped_ICU_ctrl'),'imperial_eskd':('covid_positive','covid_negative'),'giroux2022':('severe','mild'),'ji2025_chili':('TOL,FU1','BC,AC')}
+for cohort,arm in pairs:
+ for j in [x for x in jobs if x['family']=='cv' and x['cohort']==cohort and x['old_arm']==arm]:
+  d=workspace/f"generated/{cohort}/fold{j['fold']}";d.mkdir(parents=True,exist_ok=True)
+  for suffix in ['.npz','.log']:
+   dest=d/(arm+'__raw'+suffix);source=Path(j['output'])/('generated'+suffix)
+   if not dest.exists():dest.symlink_to(source)
+  dest=workspace/f"data/{cohort}/fold{j['fold']}";dest.parent.mkdir(parents=True,exist_ok=True)
+  if not dest.exists():dest.symlink_to(F/f"data/{cohort}/fold{j['fold']}",target_is_directory=True)
+ out=P/f'payload/pooled/{cohort}/{arm}';PO.main([cohort,'--arms',arm+'__raw','--out',str(out)])
+ argv=['--dataset',cohort,'--out',str(out/'score'),'--arm',f'trunk4x={out}/{arm}__raw.npz','--threads','4']
+ if cohort in groups:argv+=['--case-groups',groups[cohort][0],'--control-groups',groups[cohort][1]]
+ else:argv+=['--no-contrast','--no-deg']
+ FT.main(argv)
+(P/'payload/pooled/DONE.json').write_text(json.dumps({'pooled_groups':pairs,'folds_per_group':5,'one_heldout_prediction_per_donor':True},indent=2)+'\n')