85 lines
5.3 KiB
Python
85 lines
5.3 KiB
Python
"""Frozen fold/pool selection and lazy targets, rejecting that fold's test before I/O."""
|
|
import fcntl
|
|
import json
|
|
from pathlib import Path
|
|
import numpy as np
|
|
from freeze_g1_components import sha
|
|
from s2_recovery_supervisor import save
|
|
from s2_pilot_data import permitted_role,read_non_test_fill_time,validate_query_targets
|
|
|
|
|
|
def select_cell(roster,fold,pool):
|
|
assert fold in range(5) and pool in [25,50,100]
|
|
selected={};roles=dict(fold=fold,pool=pool,learning_parts=[],validation_parts=[],sealed_test_parts=[])
|
|
for row in roster['parts']:
|
|
a=row['assignments'][fold];assert a['fold']==fold
|
|
if a['role']=='test':roles['sealed_test_parts'].append(row['case']);continue
|
|
if not row['included']:continue
|
|
if a['role']=='learning' and str(pool) not in a['learning_pools']:continue
|
|
roles[a['role']+'_parts'].append(row['case']);selected[row['case']]=row
|
|
for key in ['learning_parts','validation_parts','sealed_test_parts']:roles[key].sort()
|
|
assert roles['learning_parts'] and roles['validation_parts']
|
|
assert not set(selected)&set(roles['sealed_test_parts'])
|
|
return selected,roles
|
|
|
|
|
|
def ensure_targets(root,c,row,roles,old_labels):
|
|
case=row['case'];role=permitted_role(roles,case) # before any file/cache/archive access
|
|
prep=row['preparation'];source=Path(prep['preparation_root'])
|
|
if case in old_labels:
|
|
old=old_labels[case]
|
|
assert old['nodes']==row['nodes'] and old['t_set']==prep['t_set']
|
|
assert old['input_sha256']['queries.npz']==prep['output_sha256']['queries.npz']
|
|
path=Path(old['label_path']);digest=old['input_sha256']['labels.npz']
|
|
assert sha(path)==digest
|
|
return path,digest,'previous_non_test_target_reused_after_current_fold_role_check'
|
|
cache=Path(root)/'fold-targets'/str(roles['fold'])/case;cache.mkdir(parents=True,exist_ok=True)
|
|
with (cache/'target.lock').open('a') as lock:
|
|
fcntl.flock(lock,fcntl.LOCK_EX)
|
|
if (cache/'failure.json').exists():raise RuntimeError('Prior target preparation failure; no silent retry')
|
|
if (cache/'receipt.json').exists():
|
|
receipt=json.loads((cache/'receipt.json').read_text())
|
|
assert receipt['case']==case and receipt['fold']==roles['fold']
|
|
assert receipt['queries_sha256']==prep['output_sha256']['queries.npz']
|
|
assert receipt['roster_sha256']==c['roster_sha256']
|
|
assert sha(cache/'labels.npz')==receipt['sha256']
|
|
return cache/'labels.npz',receipt['sha256'],'current_fold_non_test_target_cache'
|
|
if (cache/'started.json').exists():raise RuntimeError('Interrupted target preparation; no silent retry')
|
|
save(cache/'started.json',dict(case=case,fold=roles['fold'],role_at_creation=role,roster_sha256=c['roster_sha256']))
|
|
try:
|
|
st=Path(c['archive']).stat();ver=c['archive_stat']
|
|
assert (st.st_size,st.st_mtime_ns,st.st_ino)==(ver['bytes'],ver['mtime_ns'],ver['inode'])
|
|
for name in ['geometry.npz','queries.npz']:assert sha(source/name)==prep['output_sha256'][name]
|
|
with np.load(source/'geometry.npz',allow_pickle=False) as z:raw_ids=z['raw_node_ids']
|
|
with np.load(source/'queries.npz',allow_pickle=False) as q:
|
|
ids=q['anchor_ids'];eligible=q['eligible_s2'];counts=q['multiplicity']
|
|
values,provenance=read_non_test_fill_time(c['archive'],case,raw_ids,roles)
|
|
target=validate_query_targets(values,ids,eligible,prep['t_set'])
|
|
np.savez_compressed(cache/'labels.npz',anchor_ids=ids[eligible],raw_node_ids=raw_ids[ids[eligible]],
|
|
multiplicity=counts[eligible],seconds=values[ids[eligible]],target_t_star=target)
|
|
digest=sha(cache/'labels.npz')
|
|
save(cache/'receipt.json',dict(case=case,fold=roles['fold'],role_at_creation=role,sha256=digest,
|
|
queries_sha256=prep['output_sha256']['queries.npz'],roster_sha256=c['roster_sha256'],provenance=provenance,
|
|
outer_fold_test_labels_read=False))
|
|
return cache/'labels.npz',digest,'new_current_fold_non_test_target'
|
|
except Exception as exc:
|
|
save(cache/'failure.json',dict(error_type=type(exc).__name__,message=str(exc),case=case,fold=roles['fold']))
|
|
raise
|
|
|
|
|
|
def cell_records(root,c,run):
|
|
assert sha(c['roster'])==c['roster_sha256']
|
|
roster=json.loads(Path(c['roster']).read_text())
|
|
rows,roles=select_cell(roster,run['fold'],run['pool'])
|
|
assert sha(c['old_labels_manifest'])==c['old_labels_manifest_sha256']
|
|
old={r['case']:r for r in json.loads(Path(c['old_labels_manifest']).read_text())['ready_parts']}
|
|
records={};audit=[]
|
|
for case,row in sorted(rows.items()):
|
|
label,digest,mode=ensure_targets(root,c,row,roles,old);prep=row['preparation']
|
|
records[case]=dict(case=case,nodes=row['nodes'],component_id=row['component_id'],t_set=prep['t_set'],
|
|
preparation_root=prep['preparation_root'],label_path=str(label),
|
|
input_sha256={'base.npy':prep['output_sha256']['base.npy'],'queries.npz':prep['output_sha256']['queries.npz'],'labels.npz':digest})
|
|
audit.append(dict(case=case,role=permitted_role(roles,case),mode=mode,label_sha256=digest))
|
|
manifest=dict(failed_parts=[dict(case=r['case'],reason=r['exclusion_reason']) for r in roster['parts'] if not r['included']])
|
|
return records,roles,manifest,audit
|