Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/gpu_priority.py

@@ -0,0 +1,68 @@
+"""Own exactly nine x1 diffusion units; preserve x4 process and all in-flight children."""
+from pathlib import Path
+import os,sys,json,signal,subprocess,threading,fcntl,time
+from concurrent.futures import ThreadPoolExecutor
+R=Path(__file__).resolve().parent;S=R.parents[1];M=S.parents[1];X=M/'plans/f01_trunk4x_complete_20261013'
+sys.path[:0]=[str(S/'tools'),str(X/'tools')]
+import campaign
+from runtime import Runtime,atomic_json,stamp
+from dual_runtime import RemoteRuntime,ssh
+from two_host_resume import unit_support
+LOCK=threading.Lock();STOP=threading.Event()
+def state(**kw):
+ with LOCK:
+  f=R/'GPU_STATUS.json';j=json.loads(f.read_text()) if f.exists() else {'completed':[],'running':{}}
+  j.update(kw,at=stamp());atomic_json(f,j)
+class RemoteX1(RemoteRuntime):
+ def execute(self,name,argv,**kw):
+  self.pending_outputs=[str(p) for p in kw.get('outputs',[])]
+  return super().execute(name,argv,**kw)
+ def wrapped_command(self,name,argv,resource,memory_gib,threads):
+  command=super().wrapped_command(name,argv,resource,memory_gib,threads)
+  req=R/'transport'/f'{name}.json'
+  atomic_json(req,{'command':command,'outputs':self.pending_outputs,'receipt':str(req.with_suffix('.verified.json'))})
+  return [sys.executable,str(R/'transport.py'),str(req)]
+ def execution_metadata(self,argv=None,command=None):
+  j=super().execution_metadata(argv,command);j['canonical_output_transfer']='Verified remote SHA256 -> server_1';return j
+
+def main():
+ units=json.loads((R/'GPU_UNITS.json').read_text());owners=json.loads((R/'OWNERS.json').read_text())
+ assert len(units)==len(set(units))==9 and set(units)==set(owners)
+ audit=json.loads((R/'reuse/REUSE_AUDIT.json').read_text())
+ assert audit['state']=='pass_no_exact_reuse_found' and {u['unit'] for u in audit['units']}==set(units)
+ with (S/'.campaign.lock').open('a') as lock:
+  fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
+  matches=[]
+  for proc in Path('/proc').iterdir():
+   if not proc.name.isdigit():continue
+   try:argv=proc.joinpath('cmdline').read_bytes().split(b'\0')
+   except (FileNotFoundError,ProcessLookupError,PermissionError):continue
+   if argv[0].endswith(b'/python') and str(X/'tools/downstream.py').encode() in argv:matches.append(proc)
+  assert len(matches)==1,[(p.name,(p/'cmdline').read_bytes()) for p in matches]
+  proc=matches[0];j={'pid':int(proc.name),'start_ticks':(proc/'stat').read_text().split()[21],'cmdline':(proc/'cmdline').read_bytes().decode().replace('\0',' '),'at':stamp(),'scope':'Coordinator only; active systemd/SSH compute children continue; receipt wall_seconds includes pause'}
+  atomic_json(R/'X4_PAUSE.json',j);os.kill(j['pid'],signal.SIGSTOP);state(phase='x1_priority_x4_scheduler_suspended')
+  def lane(host):
+   rt=Runtime(S) if host=='server_1' else RemoteX1(S)
+   for u in units:
+    if STOP.is_set():return
+    if owners[u]!=host:continue
+    try:
+     with LOCK:
+      q=json.loads((R/'GPU_STATUS.json').read_text());q['running'][host]=u;q['at']=stamp();atomic_json(R/'GPU_STATUS.json',q)
+     path,_,support=unit_support(S,u);campaign.run_diffusion(rt,path)
+     atomic_json(R/'units'/f'{u}.json',{'state':'diffusion_completed','host':host,'support_sha256':support['sha256'],'at':stamp(),'scsemi':'separate existing protocol; not required to finish PBISC x1 generation'})
+     with LOCK:
+      q=json.loads((R/'GPU_STATUS.json').read_text());q['completed'].append(u);q['running'].pop(host,None);q['at']=stamp();atomic_json(R/'GPU_STATUS.json',q)
+    except BaseException:
+     STOP.set();raise
+  with ThreadPoolExecutor(max_workers=2) as pool:
+   futures=[pool.submit(lane,h) for h in ['server_1','server_2']]
+   for f in futures:f.result()
+  state(phase='all_nine_diffusion_completed')
+
+def terminated(*_):raise SystemExit('Controller stop requested; x4 resumed in finally')
+if __name__=='__main__':
+ signal.signal(signal.SIGTERM,terminated);signal.signal(signal.SIGINT,terminated)
+ try:main()
+ except BaseException as e:state(phase='stopped_needs_inspection',error=str(e));raise
+ finally:subprocess.run([sys.executable,str(R/'resume_x4.py')],check=True)

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/mirror_diffusion.py

@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+"""Mirror exactly nine finished x1 diffusion units, with no training or generation.
+
+The original Runtime.can_skip contract is replayed on both hosts. Existing
+different files are preserved, never replaced. Run --self-test during compute;
+the default action refuses to transfer before all nine GPU units are complete.
+"""
+from __future__ import annotations
+
+import argparse
+from contextlib import contextmanager
+from datetime import datetime, timezone
+import fcntl
+import hashlib
+import json
+import os
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+import tempfile
+import unittest
+
+R = Path(__file__).resolve().parent
+S = R.parents[1]
+DEST = R / 'mirror'
+REMOTE_PY = '/home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python'
+CPU_PY = '/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python'
+HOST = 'spark-0110'
+UNITS = [f'ji2025_chili-disease-draw{i}' for i in (2, 3, 4)] + [
+    f'immicro-healthy-fold{fold}-n{n}' for fold in (0, 1) for n in (10, 20, 40)]
+SSH = ['ssh', '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=15',
+       '-o', 'ServerAliveInterval=15', '-o', 'ServerAliveCountMax=3', HOST]
+
+
+def digest(path: Path) -> str:
+    with path.open('rb') as f:
+        return hashlib.file_digest(f, 'sha256').hexdigest()
+
+
+def encoded(value: object) -> bytes:
+    return (json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + '\n').encode()
+
+
+def once(path: Path, data: bytes) -> None:
+    """Atomic create only; accept exact bytes on a repeated invocation."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists() or path.is_symlink():
+        if path.is_symlink() or not path.is_file() or path.read_bytes() != data:
+            raise RuntimeError(f'Existing different file preserved: {path}')
+        return
+    fd, name = tempfile.mkstemp(prefix='.mirror-', dir=path.parent)
+    temp = Path(name)
+    try:
+        with os.fdopen(fd, 'wb') as f:
+            f.write(data)
+            f.flush()
+            os.fsync(f.fileno())
+        try:
+            os.link(temp, path)
+        except FileExistsError:
+            if path.is_symlink() or path.read_bytes() != data:
+                raise RuntimeError(f'Concurrent different file preserved: {path}') from None
+    finally:
+        temp.unlink(missing_ok=True)
+
+
+def ssh_python(code: str, args: list[str] | None = None,
+               data: object | None = None) -> str:
+    argv = [REMOTE_PY, '-c', code, *(args or [])]
+    return subprocess.check_output(SSH + [shlex.join(argv)], text=True,
+                                   input=None if data is None else json.dumps(data))
+
+
+@contextmanager
+def locks():
+    """Both original worker locks stay held throughout copying and skip proof."""
+    with (S / '.campaign.lock').open('a') as local:
+        fcntl.flock(local, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        code = ('import fcntl,sys; f=open(sys.argv[1],"a"); '
+                'fcntl.flock(f,fcntl.LOCK_EX|fcntl.LOCK_NB); '
+                'print("LOCKED",flush=True); sys.stdin.read()')
+        process = subprocess.Popen(SSH + [shlex.join([REMOTE_PY, '-c', code,
+                                                     str(S / '.campaign.lock')])],
+                                   text=True, stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        try:
+            assert process.stdout is not None
+            if process.stdout.readline().strip() != 'LOCKED':
+                error = process.stderr.read() if process.stderr else ''
+                raise RuntimeError('Remote campaign lock unavailable: ' + error)
+            yield
+            if process.poll() is not None:
+                raise RuntimeError('Remote lock session ended before verification')
+        finally:
+            if process.stdin:
+                process.stdin.close()
+            try:
+                code = process.wait(timeout=20)
+            except subprocess.TimeoutExpired:
+                process.terminate()
+                code = process.wait(timeout=10)
+            if code and sys.exc_info()[0] is None:
+                raise RuntimeError(f'Remote lock session failed: {code}')
+
+
+def relative(unit: str) -> Path:
+    if unit not in UNITS:
+        raise ValueError('Outside the exact requested nine units')
+    for p in (S / 'protocol/splits').glob('**/support.json'):
+        rel = p.relative_to(S / 'protocol/splits').parent
+        if '-'.join(rel.parts) == unit:
+            return rel
+    raise ValueError('Missing support manifest: ' + unit)
+
+
+def output_contract(unit: str, suffix: str) -> list[Path]:
+    rel = relative(unit)
+    if suffix == 'train':
+        return [S / 'runs' / rel / 'lora/checkpoint_ft.pt',
+                S / 'runs' / rel / 'lora/RUN.json']
+    if suffix not in ('lora', 'pairedcal'):
+        raise ValueError('Unknown diffusion operation')
+    return [S / 'generated' / rel / f'{suffix}.npz',
+            S / 'generated' / rel / f'{suffix}.log']
+
+
+def validate_completed(record: dict, expected: list[Path]) -> None:
+    if record.get('state') != 'completed' or not record.get('signature'):
+        raise RuntimeError('Only signed completed receipts can be mirrored')
+    outputs = record.get('outputs', [])
+    if [row.get('path') for row in outputs] != [str(p.resolve()) for p in expected]:
+        raise RuntimeError('Receipt output contract differs from exact nine-unit scope')
+    if any(not isinstance(x.get('sha256'), str) or len(x['sha256']) != 64 for x in outputs):
+        raise RuntimeError('Receipt lacks output SHA256')
+
+
+PROBE = '''from pathlib import Path
+import sys,json
+S=Path(sys.argv[1]);units=json.loads(sys.argv[2]);sys.path.insert(0,str(S/'tools'))
+import campaign
+from runtime import Runtime
+class Probe(Runtime):
+ def __init__(self,root):super().__init__(root);self.results=[]
+ def execute(self,name,argv,**kw):
+  sig=self.signature(argv,kw.get('inputs',[]))
+  if not self.can_skip(name,sig,kw.get('outputs',[])):
+   raise RuntimeError('Would launch an operation; no execution allowed: '+name)
+  self.results.append({'operation':name,'signature':sig,'verified_skip':True})
+  return False
+ def preflight(self,*args,**kw):raise AssertionError('Probe must never launch compute')
+ def wrapped_command(self,*args,**kw):raise AssertionError('Probe must never create a command')
+rt=Probe(S)
+for unit in units:
+ matches=[p for p in campaign.discover_units() if campaign.name(p)==unit]
+ assert len(matches)==1
+ campaign.run_diffusion(rt,matches[0])
+assert len(rt.results)==27 and len({x['operation'] for x in rt.results})==27
+print(json.dumps({'state':'verified_skip_only','operations':rt.results,'gpu_launched':False}))
+'''
+
+
+def source_probe() -> dict:
+    env = dict(os.environ, CUDA_VISIBLE_DEVICES='', PYTHONDONTWRITEBYTECODE='1',
+               OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1')
+    return json.loads(subprocess.check_output([CPU_PY, '-c', PROBE,
+                                               str(S), json.dumps(UNITS)], env=env, text=True))
+
+
+REMOTE_STAT = '''from pathlib import Path
+import sys,json,hashlib
+out={}
+for raw in json.load(sys.stdin):
+ p=Path(raw)
+ if p.is_symlink():raise RuntimeError('Symlink target preserved: '+raw)
+ if not p.exists():out[raw]=None;continue
+ if not p.is_file():raise RuntimeError('Non-file target preserved: '+raw)
+ st=p.stat();out[raw]={'path':str(p.resolve()),'bytes':st.st_size,'mtime_ns':st.st_mtime_ns,'sha256':hashlib.file_digest(p.open('rb'),'sha256').hexdigest()}
+print(json.dumps(out))
+'''
+
+
+INSTALL = '''from pathlib import Path
+import sys,os,hashlib,json
+src=Path(sys.argv[1]);dst=Path(sys.argv[2]);expected=sys.argv[3]
+def sha(p):return hashlib.file_digest(p.open('rb'),'sha256').hexdigest()
+assert src.is_file() and not src.is_symlink() and sha(src)==expected
+dst.parent.mkdir(parents=True,exist_ok=True)
+try:os.link(src,dst)
+except FileExistsError:
+ assert dst.is_file() and not dst.is_symlink() and sha(dst)==expected,'Conflicting destination preserved: '+str(dst)
+assert sha(dst)==expected
+src.unlink()
+print(json.dumps({'state':'verified','path':str(dst),'sha256':expected}))
+'''
+
+
+def copy_if_missing(source: Path, target: Path, expected: str, known: dict | None) -> None:
+    if known is not None:
+        if known['sha256'] != expected:
+            raise RuntimeError('Conflicting remote file preserved: ' + str(target))
+        return
+    staging = DEST / 'staging' / (hashlib.sha256(str(target).encode()).hexdigest() + '-' + expected)
+    ssh_python('from pathlib import Path; import sys; Path(sys.argv[1]).mkdir(parents=True,exist_ok=True)',
+               [str(staging.parent)])
+    subprocess.run(['rsync', '-a', '--protect-args', str(source), HOST + ':' + str(staging)], check=True)
+    ssh_python(INSTALL, [str(staging), str(target), expected])
+
+
+def normalize_receipt(record: dict, stats: dict, raw: Path, raw_sha: str) -> dict:
+    result = json.loads(json.dumps(record))
+    for output in result['outputs']:
+        actual = stats[output['path']]
+        if actual is None or actual['sha256'] != output['sha256'] or actual['bytes'] != output['bytes']:
+            raise RuntimeError('Destination payload differs from canonical source receipt')
+        output.update({key:actual[key] for key in ('path', 'bytes', 'mtime_ns')})
+    result['mirror_provenance'] = {
+        'schema': 'pbisc.strict9.diffusion-mirror.v1',
+        'source_receipt_host': 'server_1',
+        'source_receipt': str(raw),
+        'source_receipt_sha256': raw_sha,
+        'destination_host': 'server_2',
+        'normalization': 'Destination output path, bytes and mtime_ns only; original execution metadata and signature preserved'}
+    return result
+
+
+def main() -> None:
+    status = json.loads((R / 'GPU_STATUS.json').read_text())
+    if (status.get('phase') != 'all_nine_diffusion_completed' or
+            set(status.get('completed', [])) != set(UNITS) or
+            len(status.get('completed', [])) != 9):
+        raise RuntimeError('Nine GPU units have not all completed; no transfer attempted')
+    if set(json.loads((R / 'GPU_UNITS.json').read_text())) != set(UNITS):
+        raise RuntimeError('GPU unit ownership differs from the exact requested nine')
+    audit = json.loads((R / 'reuse/REUSE_AUDIT.json').read_text())
+    if audit.get('state') != 'pass_no_exact_reuse_found':
+        raise RuntimeError('No passing reuse audit')
+    DEST.mkdir(parents=True, exist_ok=True)
+    with locks():
+        checked_source = source_probe()
+        once(DEST / 'SOURCE_PROBE.json', encoded(checked_source))
+        receipts=[]
+        outputs={}
+        for unit in UNITS:
+            for suffix in ('train', 'lora', 'pairedcal'):
+                name=f'{unit}-{suffix}'
+                path=S/'receipts'/f'{name}.json'
+                raw=DEST/'source_receipts'/path.name
+                blob=path.read_bytes();record=json.loads(blob)
+                validate_completed(record,output_contract(unit,suffix))
+                once(raw,blob)
+                receipts.append((name,record,raw,hashlib.sha256(blob).hexdigest()))
+                for output in record['outputs']:
+                    if output['path'] in outputs and outputs[output['path']]!=output['sha256']:
+                        raise RuntimeError('Inconsistent source output hashes')
+                    outputs[output['path']]=output['sha256']
+        if len(receipts)!=27 or len(outputs)!=54:
+            raise RuntimeError('Unexpected operation/artifact count')
+        remote_stats=json.loads(ssh_python(REMOTE_STAT,data=list(outputs)))
+        for raw,expected in outputs.items():
+            if digest(Path(raw))!=expected:
+                raise RuntimeError('Canonical source changed after probe: '+raw)
+            copy_if_missing(Path(raw),Path(raw),expected,remote_stats[raw])
+        # Re-read every output after all transfers; normalized receipts are installed only afterward.
+        remote_stats=json.loads(ssh_python(REMOTE_STAT,data=list(outputs)))
+        for name,record,raw,raw_sha in receipts:
+            remote_raw=json.loads(ssh_python(REMOTE_STAT,data=[str(raw)]))[str(raw)]
+            copy_if_missing(raw,raw,raw_sha,remote_raw)
+            normalized=normalize_receipt(record,remote_stats,raw,raw_sha)
+            staged=DEST/'normalized_receipts'/f'{name}.json'
+            once(staged,encoded(normalized))
+            target=S/'receipts'/f'{name}.json'
+            existing=json.loads(ssh_python(REMOTE_STAT,data=[str(target)]))[str(target)]
+            copy_if_missing(staged,target,digest(staged),existing)
+        # CUDA is explicitly hidden. Probe overrides execute, preflight and wrapper: no launch path exists.
+        remote_probe_code="import os;os.environ['CUDA_VISIBLE_DEVICES']='';os.environ['PYTHONDONTWRITEBYTECODE']='1';os.environ['OPENBLAS_NUM_THREADS']='1';os.environ['OMP_NUM_THREADS']='1';\n"+PROBE
+        checked_remote=json.loads(ssh_python(remote_probe_code,[str(S),json.dumps(UNITS)]))
+        once(DEST/'REMOTE_PROBE.json',encoded(checked_remote))
+        evidence={'schema':'pbisc.strict9.diffusion-mirror.v1','state':'verified','units':UNITS,
+                  'source_host':'server_1','destination_host':'server_2','completed_receipts':27,
+                  'artifacts':54,'remote_verified_skips':len(checked_remote['operations']),
+                  'gpu_launched':False,'source_probe_sha256':digest(DEST/'SOURCE_PROBE.json'),
+                  'remote_probe_sha256':digest(DEST/'REMOTE_PROBE.json'),
+                  'source_receipts':[{ 'operation':n,'path':str(p),'sha256':h} for n,_,p,h in receipts],
+                  'outputs':remote_stats}
+        once(R/'MIRROR_VERIFIED.json',encoded(evidence))
+        print(json.dumps({'state':'verified','operations':27,'artifacts':54,'receipt':str(R/'MIRROR_VERIFIED.json')}))
+
+
+class Tests(unittest.TestCase):
+    def test_exact_scope(self):
+        self.assertEqual(len(UNITS),9)
+        self.assertEqual(len(set(UNITS)),9)
+        with self.assertRaises(ValueError):relative('unexpected')
+
+    def test_once_reuses_exact_and_preserves_conflict(self):
+        with tempfile.TemporaryDirectory() as folder:
+            p=Path(folder)/'record.json';once(p,b'one');once(p,b'one')
+            with self.assertRaises(RuntimeError):once(p,b'two')
+            self.assertEqual(p.read_bytes(),b'one')
+
+    def test_normalize_only_stats_and_provenance(self):
+        row={'state':'completed','signature':'unchanged','execution':{'host':'source'},
+             'outputs':[{'path':'/same','bytes':3,'mtime_ns':1,'sha256':'a'*64}]}
+        result=normalize_receipt(row,{'/same':{'path':'/same','bytes':3,'mtime_ns':9,'sha256':'a'*64}},Path('/raw'),'b'*64)
+        self.assertEqual(row['outputs'][0]['mtime_ns'],1)
+        self.assertEqual(result['outputs'][0]['mtime_ns'],9)
+        self.assertEqual(result['signature'],row['signature'])
+        self.assertEqual(result['execution'],row['execution'])
+        result.pop('mirror_provenance');result['outputs'][0]['mtime_ns']=1
+        self.assertEqual(result,row)
+
+    def test_bad_hash_blocks_receipt(self):
+        row={'outputs':[{'path':'/same','bytes':3,'sha256':'a'*64}]}
+        with self.assertRaises(RuntimeError):
+            normalize_receipt(row,{'/same':{'path':'/same','bytes':3,'mtime_ns':9,'sha256':'b'*64}},Path('/raw'),'c'*64)
+
+    def test_noncompleted_and_out_of_scope_blocked(self):
+        with self.assertRaises(RuntimeError):validate_completed({'state':'running'},[])
+        with self.assertRaises(RuntimeError):
+            validate_completed({'state':'completed','signature':'s','outputs':[{'path':'/other','sha256':'a'*64}]},[Path('/expected')])
+
+
+if __name__=='__main__':
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--self-test',action='store_true')
+    args=parser.parse_args()
+    if args.self_test:
+        result=unittest.TextTestRunner(verbosity=2).run(unittest.defaultTestLoader.loadTestsFromTestCase(Tests))
+        raise SystemExit(0 if result.wasSuccessful() else 1)
+    main()

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/recoveries/x1_priority_completion_20261015/resume_x4.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+import os,signal,json,datetime
+R=Path(__file__).resolve().parent
+p=R/'X4_PAUSE.json'
+if p.exists():
+ j=json.loads(p.read_text());proc=Path('/proc')/str(j['pid'])
+ if proc.exists() and proc.joinpath('stat').read_text().split()[21]==j['start_ticks'] and b'/f01_trunk4x_complete_20261013/tools/downstream.py' in proc.joinpath('cmdline').read_bytes():
+  os.kill(j['pid'],signal.SIGCONT)
+  (R/'X4_RESUMED.json').write_text(json.dumps({'pid':j['pid'],'at':datetime.datetime.now(datetime.timezone.utc).isoformat(),'reason':'x1 GPU stage ended or controller stopped; existing x4 coordinator preserved'},indent=2)+'\n')

paper-releases/pbisc-diffusion/updates/20261015T121654Z-x1-nine-core40-deck/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/runs/immicro/healthy/fold1/n40/lora/RUN.json

@@ -0,0 +1,450 @@
+{
+ "schema": "pbisc_sdd.ft_intradataset.run.v1",
+ "source_checkpoint": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt",
+ "source_checkpoint_sha256": "8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633",
+ "dataset_dir": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro",
+ "condition_npz": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/conditions_raw_fixed.npz",
+ "condition_npz_sha256": "2be5717d19e86bdf38e4838d4bd2886a211ba78bfbfe749c458305a3e0ac2dcc",
+ "fold": 0,
+ "mode": "lora",
+ "trainable": {
+  "mode": "lora",
+  "lora_layers": [
+   "time_encoder.0",
+   "time_encoder.2",
+   "condition_encoder.0",
+   "condition_encoder.3",
+   "context_mixer.2",
+   "down_blocks.0.input_projection",
+   "down_blocks.0.context_projection.1",
+   "down_blocks.1.input_projection",
+   "down_blocks.1.context_projection.1",
+   "down_blocks.2.input_projection",
+   "down_blocks.2.context_projection.1",
+   "down_blocks.3.input_projection",
+   "down_blocks.3.context_projection.1",
+   "up_blocks.0.input_projection",
+   "up_blocks.0.context_projection.1",
+   "up_blocks.1.input_projection",
+   "up_blocks.1.context_projection.1",
+   "up_blocks.2.input_projection",
+   "up_blocks.2.context_projection.1",
+   "output_trunk.0",
+   "value_head",
+   "active_head"
+  ],
+  "lora_rank": 16,
+  "lora_alpha": 16.0,
+  "n_trainable": 1296224,
+  "n_total_base": 54185184,
+  "trainable_tensors": 44
+ },
+ "lr": 0.0005,
+ "warmup": 200,
+ "batch_size": 256,
+ "ema_decay": 0.999,
+ "max_steps": 3000,
+ "steps_run": 3000,
+ "eval_every": 250,
+ "patience": 8,
+ "train_subset": null,
+ "train_donors_file": null,
+ "support_manifest": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/protocol/splits/immicro/healthy/fold1/n40/support.json",
+ "support_sha256": "e4909b732024af62d8332b9fc37adb0f7bda2024884b74ac3b4059ecf371d2c5",
+ "train_donor_ids": [
+  "HS25",
+  "HS95",
+  "HS77",
+  "HS14",
+  "HS108",
+  "HS58",
+  "HS90",
+  "HS102",
+  "HS27",
+  "HS45",
+  "HS66",
+  "HS75",
+  "HS83",
+  "HS43",
+  "HS107",
+  "HS1",
+  "HS97",
+  "HS73",
+  "HS103",
+  "HS23",
+  "HS52",
+  "HS4",
+  "HS40",
+  "HS85",
+  "HS89",
+  "HS67",
+  "HS60",
+  "HS8",
+  "HS31",
+  "HS37",
+  "HS106",
+  "HS62",
+  "HS15",
+  "HS38",
+  "HS63",
+  "HS87",
+  "HS98",
+  "HS28",
+  "HS69",
+  "HS78"
+ ],
+ "excluded_selected_donor_visits": [],
+ "fixed_steps": 3000,
+ "selected_step": 3000,
+ "selected_inner_val_loss": NaN,
+ "pretrained_inner_val_loss": NaN,
+ "train_rows": [
+  "HS1",
+  "HS4",
+  "HS8",
+  "HS14",
+  "HS15",
+  "HS23",
+  "HS25",
+  "HS27",
+  "HS28",
+  "HS31",
+  "HS37",
+  "HS38",
+  "HS40",
+  "HS43",
+  "HS45",
+  "HS52",
+  "HS58",
+  "HS60",
+  "HS62",
+  "HS63",
+  "HS66",
+  "HS67",
+  "HS69",
+  "HS73",
+  "HS75",
+  "HS77",
+  "HS78",
+  "HS83",
+  "HS85",
+  "HS87",
+  "HS89",
+  "HS90",
+  "HS95",
+  "HS97",
+  "HS98",
+  "HS102",
+  "HS103",
+  "HS106",
+  "HS107",
+  "HS108"
+ ],
+ "inner_val_rows": [],
+ "test_rows_never_loaded_for_training": [
+  "HS2",
+  "HS12",
+  "HS16",
+  "HS17",
+  "HS21",
+  "HS35",
+  "HS36",
+  "HS39",
+  "HS44",
+  "HS46",
+  "HS47",
+  "HS48",
+  "HS51",
+  "HS56",
+  "HS57",
+  "HS65",
+  "HS68",
+  "HS72",
+  "HS84",
+  "HS92",
+  "HS96",
+  "HS109"
+ ],
+ "max_abs_weight_change": 0.8787888884544373,
+ "n_tensors_changed": 22,
+ "seed": 20260927,
+ "wall_seconds": 124.6,
+ "written_utc": "2026-10-15T11:54:59.625799+00:00",
+ "support_expression_isolation": {
+  "schema": "pbisc.paper.support-expression-isolation.v1",
+  "support_manifest": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/protocol/splits/immicro/healthy/fold1/n40/support.json",
+  "support_sha256": "e4909b732024af62d8332b9fc37adb0f7bda2024884b74ac3b4059ecf371d2c5",
+  "cohort": "immicro",
+  "unit": "fold1_n40",
+  "train_sample_ids": [
+   "HS25",
+   "HS95",
+   "HS77",
+   "HS14",
+   "HS108",
+   "HS58",
+   "HS90",
+   "HS102",
+   "HS27",
+   "HS45",
+   "HS66",
+   "HS75",
+   "HS83",
+   "HS43",
+   "HS107",
+   "HS1",
+   "HS97",
+   "HS73",
+   "HS103",
+   "HS23",
+   "HS52",
+   "HS4",
+   "HS40",
+   "HS85",
+   "HS89",
+   "HS67",
+   "HS60",
+   "HS8",
+   "HS31",
+   "HS37",
+   "HS106",
+   "HS62",
+   "HS15",
+   "HS38",
+   "HS63",
+   "HS87",
+   "HS98",
+   "HS28",
+   "HS69",
+   "HS78"
+  ],
+  "train_donor_ids": [
+   "HS25",
+   "HS95",
+   "HS77",
+   "HS14",
+   "HS108",
+   "HS58",
+   "HS90",
+   "HS102",
+   "HS27",
+   "HS45",
+   "HS66",
+   "HS75",
+   "HS83",
+   "HS43",
+   "HS107",
+   "HS1",
+   "HS97",
+   "HS73",
+   "HS103",
+   "HS23",
+   "HS52",
+   "HS4",
+   "HS40",
+   "HS85",
+   "HS89",
+   "HS67",
+   "HS60",
+   "HS8",
+   "HS31",
+   "HS37",
+   "HS106",
+   "HS62",
+   "HS15",
+   "HS38",
+   "HS63",
+   "HS87",
+   "HS98",
+   "HS28",
+   "HS69",
+   "HS78"
+  ],
+  "source_cells": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/data/immicro/cells_panel6k.npz",
+  "source_cells_sha256": "e1168468b621183604038b79280f46961c5819fe2386d9da0b454f7db642742a",
+  "source_folds_sha256": "0adc10f4ac973e5b7558effbea0fd6950a6bf59e5af1d3a376e12eb00bf6a643",
+  "isolated_cells": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold1/n40/cells_support_only.npz",
+  "isolated_cells_sha256": "0d8c6a634556786cc437b600999e4f85294543d860489366d98b10818515e11a",
+  "builder_sha256": "762f5f7bbf908c478544b0c5c05a8fbf6c3bf63eff6a2d7af88105473c1c20a2",
+  "audit": {
+   "selected_sample_rows": [
+    0,
+    3,
+    6,
+    12,
+    13,
+    20,
+    22,
+    24,
+    25,
+    28,
+    33,
+    34,
+    36,
+    39,
+    41,
+    48,
+    54,
+    56,
+    58,
+    59,
+    62,
+    63,
+    65,
+    69,
+    71,
+    73,
+    74,
+    79,
+    81,
+    83,
+    85,
+    86,
+    91,
+    93,
+    94,
+    97,
+    98,
+    101,
+    102,
+    103
+   ],
+   "selected_cells": 140043,
+   "selected_nonzero_entries": 52912313,
+   "original_cell_rows": 392251,
+   "nonselected_expression_rows_empty": true,
+   "original_expression_ranges": [
+    [
+     0,
+     1504797
+    ],
+    [
+     4825033,
+     6639911
+    ],
+    [
+     9933542,
+     11206953
+    ],
+    [
+     19315918,
+     23069429
+    ],
+    [
+     31194465,
+     31896242
+    ],
+    [
+     32541625,
+     33326602
+    ],
+    [
+     34426292,
+     37519677
+    ],
+    [
+     41950421,
+     43870037
+    ],
+    [
+     48911773,
+     51123627
+    ],
+    [
+     51906420,
+     53172512
+    ],
+    [
+     55272483,
+     57119283
+    ],
+    [
+     58712027,
+     59539601
+    ],
+    [
+     68718214,
+     70214002
+    ],
+    [
+     76988645,
+     77540432
+    ],
+    [
+     79384968,
+     80446582
+    ],
+    [
+     81206228,
+     84515194
+    ],
+    [
+     87119554,
+     90363220
+    ],
+    [
+     91403069,
+     92080438
+    ],
+    [
+     97565938,
+     98898035
+    ],
+    [
+     100819709,
+     101647131
+    ],
+    [
+     102941774,
+     105564211
+    ],
+    [
+     110990986,
+     111937275
+    ],
+    [
+     113055026,
+     114897365
+    ],
+    [
+     115360655,
+     117056907
+    ],
+    [
+     118976164,
+     120737395
+    ],
+    [
+     125793775,
+     127286443
+    ],
+    [
+     128077095,
+     131666404
+    ],
+    [
+     135086776,
+     136903807
+    ],
+    [
+     140808934,
+     144456310
+    ]
+   ],
+   "cell_row_indexing": "unchanged original cell-row indices; non-support rows have empty CSR rows",
+   "data_sha256": "4fd5e20f1fd29912a4ea04875dd5b240a4f3e8ae2b0873a560f602b1f67121b7",
+   "indices_sha256": "ffd436f0c2c2e4c6d71cdc0a9abb4d3e8b65ffec75fbc3480294b522b69ee08b"
+  },
+  "expression_access": "Only selected CSR ranges interpreted. Nonselected compressed bytes may be streamed and discarded.",
+  "target_sc_aggregate_keys_accessed": [],
+  "permitted_all_row_metadata": [
+   "indptr",
+   "row_sample",
+   "shape",
+   "panel_gene_ids",
+   "panel_measured"
+  ]
+ },
+ "checkpoint_sha256": "e4877d6f68387128ce43a3d2de497754090c9b95d621f001c24a6e45e19062f8",
+ "reload_forward_max_abs_diff": 0.0
+}