178 lines
12 KiB
Python
178 lines
12 KiB
Python
"""B7 single-fold validation ranker gate; rank scores are not seconds."""
|
|
import argparse
|
|
import fcntl
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import resource
|
|
import sys
|
|
import time
|
|
import joblib
|
|
import numpy as np
|
|
import xgboost as xgb
|
|
from phase2_h1_worker_v2 import sha,checked,save
|
|
from phase2_fixed_io import freeze,verify,BASE
|
|
from s2_custody_common import prediction_inputs
|
|
from s2_custody_statistics import part_metrics
|
|
from r4bc_common import paired_difference
|
|
from r4bc_guard import supervise
|
|
from s2_recovery_monitoring import disk_usage
|
|
|
|
ROOT=BASE/'artifacts/phase2-b7-gate-2026-11-17'
|
|
PARAMS=dict(objective='rank:pairwise',tree_method='hist',device='cpu',n_estimators=100,max_depth=8,learning_rate=.1,random_state=0,n_jobs=1,lambdarank_pair_method='mean',lambdarank_num_pair_per_sample=1)
|
|
def read(p):return json.loads(Path(p).read_text())
|
|
|
|
|
|
def sample_ids(raw,cap=2048):
|
|
raw=np.asarray(raw)
|
|
if not len(raw) or np.any(np.diff(raw)<=0):raise ValueError('Expected sorted unique raw IDs')
|
|
return np.linspace(0,len(raw)-1,min(cap,len(raw)),dtype=np.int64)
|
|
|
|
|
|
def dense_rank(y):
|
|
y=np.asarray(y)
|
|
if y.ndim!=1 or not np.isfinite(y).all():raise ValueError('Invalid pairwise labels')
|
|
return np.unique(y,return_inverse=True)[1].astype(np.float32)
|
|
|
|
|
|
def gate(tau,last,undefined):
|
|
if undefined:return 'PARK_UNDEFINED_OR_COVERAGE'
|
|
return 'RETAIN_SINGLE_FOLD_FEASIBILITY' if (tau['low'] is not None and tau['low']>0) or (last['value'] is not None and last['value']>=.010) else 'PRUNE_THIS_FIXED_RANKER_RECIPE'
|
|
|
|
|
|
def check_ranker(model):
|
|
cfg=json.loads(model.get_booster().save_config());obj=cfg['learner']['objective']
|
|
if obj['name']!='rank:pairwise':raise ValueError('Unexpected ranking objective')
|
|
params=obj['lambdarank_param']
|
|
if params['lambdarank_pair_method']!='mean' or int(params['lambdarank_num_pair_per_sample'])!=1:raise ValueError('Unsupported pair method/number; no silent fallback')
|
|
return cfg
|
|
|
|
|
|
def prepare(acceptance):
|
|
tests=read(acceptance)
|
|
if tests['status']!='PASS':raise ValueError('B7 acceptance missing')
|
|
for p,h in tests['code_sha256'].items():checked(BASE/p,h)
|
|
p=BASE/'artifacts/r4bc-execution-2026-11-16/contract.json';old=read(p);rows={}
|
|
for role in ['learning','validation']:
|
|
rows[role]=sorted([r for r in old['parts'] if any(a['fold']==0 and a['role']==role and (role!='learning' or '100' in a['learning_pools']) for a in r['assignments'])],key=lambda r:r['case'])
|
|
if set(r['component_id'] for r in rows['learning']) & set(r['component_id'] for r in rows['validation']):raise ValueError('Role component leakage')
|
|
b3=BASE/'artifacts/phase2-b3-gate-2026-11-17/contract.json';baseline=read(b3)['baseline_model']
|
|
names=['phase2_b7_gate','phase2_fixed_io','phase2_h1_worker_v2','phase2_residual_math','s2_custody_common','s2_custody_statistics','r4bc_common','r4bc_guard','s2_recovery_supervisor','s2_recovery_monitoring']
|
|
ROOT.mkdir(exist_ok=False)
|
|
save(ROOT/'contract.json',dict(version='B7-one-fold-validation-v1',approval='1794892472.421479',proposal_sha256='66d5801e49470eb9465301b1b855ad8dcddfb5bbbca71c26b90ed7f2fb26f7fb',
|
|
rows=rows,baseline=baseline,parameters=PARAMS,source_sha256={str(p):sha(p),str(b3):sha(b3),str(acceptance):sha(acceptance)},
|
|
code_sha256={f'tools/{n}.py':sha(BASE/f'tools/{n}.py') for n in names},cpu=24,total_cpu_seconds=7200,setup_seconds=60,rss_bytes=8*1024**3,disk_bytes=5*1024**3,
|
|
phase_limits=dict(train=3600,predict=900,score=900),sample_policy='<=2048 uniformly spaced ascending original IDs per part, endpoint inclusive; no labels used for selection',
|
|
qid_policy='one learning part per qid, ascending part order; dense within-part target ranks, exact ties retained',
|
|
score_role='fold0 validation only; no test label access',gate='tau-b candidate-minus-A paired-component95CI lower>0 OR A-minus-candidate mean last-distance>=.010Rg; otherwise prune; incomplete/undefined park',
|
|
rank_scale='raw arbitrary rank score compared with T/t_set only as uncalibrated diagnostic L2, never seconds or a gate',new_models=1,extra_control_models=0,new_decodes=0,gpu=False,retry=False))
|
|
|
|
|
|
def config(root):
|
|
c=read(root/'contract.json')
|
|
if xgb.__version__!='2.1.4':raise ValueError('Pinned XGBoost version differs')
|
|
for p,h in {**c['code_sha256'],**c['source_sha256']}.items():checked(p,h)
|
|
for role,rows in c['rows'].items():
|
|
for r in rows:
|
|
a=next(x for x in r['assignments'] if x['fold']==0)
|
|
if a['role']!=role or (role=='learning' and '100' not in a['learning_pools']):raise PermissionError('B7 role mismatch')
|
|
return c
|
|
|
|
|
|
def array(row,name):
|
|
d=row['v5_cache'];return np.load(checked(Path(d['output'])/(name+'.npy'),d['output_sha256'][name+'.npy']),allow_pickle=False)
|
|
|
|
|
|
def train(root,c):
|
|
dest=root/'phases/train';xs=[];ys=[];qids=[];records=[];start=time.process_time()
|
|
for qid,row in enumerate(c['rows']['learning']):
|
|
raw=array(row,'raw_ids');ix=sample_ids(raw);x=array(row,'features');y=array(row,'target')
|
|
if x.shape!=(len(raw),19) or y.shape!=raw.shape:raise ValueError('B7 full cache identity mismatch')
|
|
xs.append(np.asarray(x[ix],np.float32));ys.append(dense_rank(y[ix]));qids.append(np.full(len(ix),qid,np.int64))
|
|
records.append(dict(case=row['case'],component_id=row['component_id'],qid=qid,raw_ids=list(map(int,raw[ix])),target_sha256=row['v5_cache']['output_sha256']['target.npy'],role='learning'))
|
|
save(dest/'training-access.json',records)
|
|
x=np.concatenate(xs);y=np.concatenate(ys);qid=np.concatenate(qids)
|
|
model=xgb.XGBRanker(**c['parameters']);model.fit(x,y,qid=qid,verbose=False);cfg=check_ranker(model)
|
|
model.save_model(dest/'model.ubj');save(dest/'xgboost-config.json',cfg)
|
|
save(dest/'result.json',dict(status='FIT_COMPLETE',checkpoint_sha256=sha(dest/'model.ubj'),rows=len(y),parts=len(records),cpu_seconds=time.process_time()-start,validation_labels_read=False))
|
|
|
|
|
|
def predict(root,c):
|
|
verify(root,'model');dest=root/'phases/predict';model=xgb.XGBRanker();model.load_model(root/'phases/train/model.ubj');baseline=joblib.load(checked(c['baseline']['model_path'],c['baseline']['model_sha256']));entries=[]
|
|
for row in c['rows']['validation']:
|
|
q=prediction_inputs(row);raw=array(row,'raw_ids');ix=np.searchsorted(raw,q['raw_ids'])
|
|
if np.any(ix>=len(raw)) or not np.array_equal(raw[ix],q['raw_ids']):raise ValueError('Validation query IDs differ')
|
|
x=np.asarray(array(row,'features')[ix],np.float32);rank=np.asarray(model.predict(x),np.float64);a=np.asarray(baseline.predict(x),np.float64)
|
|
if not np.isfinite(rank).all() or not np.isfinite(a).all():raise ValueError('Nonfinite validation prediction')
|
|
p=dest/(row['case']+'.npz');np.savez_compressed(p,rank=rank,A=a,raw_ids=q['raw_ids'],counts=q['counts'],near_wall=q['near_wall'],coordinates_over_Rg=q['coordinates_over_Rg'])
|
|
entries.append(dict(case=row['case'],path=str(p),sha256=sha(p),component_id=row['component_id']))
|
|
save(dest/'progress.json',dict(parts=len(entries),validation_labels_read=False))
|
|
save(dest/'manifest.json',dict(entries=entries,validation_labels_read=False))
|
|
|
|
|
|
def score(root,c):
|
|
verify(root,'predictions');dest=root/'phases/score';entries=read(root/'phases/predict/manifest.json')['entries'];by={r['case']:r for r in c['rows']['validation']};rows=[];undefined=[]
|
|
if {e['case'] for e in entries}!=set(by):raise ValueError('Incomplete validation roster')
|
|
for e in entries:
|
|
row=by[e['case']]
|
|
save(dest/'next-target-access.json',dict(case=row['case'],role='fold0_validation',target_sha256=row['v5_cache']['output_sha256']['target.npy']))
|
|
y=array(row,'target');raw=array(row,'raw_ids')
|
|
with np.load(checked(e['path'],e['sha256']),allow_pickle=False) as z:
|
|
ix=np.searchsorted(raw,z['raw_ids'])
|
|
if not np.array_equal(raw[ix],z['raw_ids']):raise ValueError('Scoring query identity changed')
|
|
result=dict(case=e['case'],component_id=row['component_id'])
|
|
for arm in ['rank','A']:
|
|
metrics=part_metrics(z[arm],y[ix],z['counts'],z['near_wall'],z['raw_ids'],z['coordinates_over_Rg'],int(e['case'].split('_')[0]));result[arm]=metrics
|
|
for name in ['last_location','kendall_tau_b']:
|
|
if metrics[name]['value'] is None:undefined.append(dict(case=e['case'],arm=arm,metric=name,reason=metrics[name]['reason']))
|
|
rows.append(result)
|
|
groups={}
|
|
for r in rows:groups.setdefault(r['component_id'],[]).append(r)
|
|
metrics={}
|
|
for name in ['last_location','kendall_tau_b','relative_l2']:
|
|
values={a:{} for a in ['rank','A']}
|
|
for g,parts in groups.items():
|
|
for a in values:
|
|
v=[r[a][name]['value'] for r in parts]
|
|
if all(x is not None for x in v):values[a][g]=float(np.mean(v))
|
|
metrics[name]=dict(means={a:float(np.mean(list(v.values()))) if v else None for a,v in values.items()},components={a:len(v) for a,v in values.items()},
|
|
rank_minus_A=paired_difference(values['rank'],values['A']),A_minus_rank=paired_difference(values['A'],values['rank']))
|
|
tau=metrics['kendall_tau_b']['rank_minus_A'];last=metrics['last_location']['A_minus_rank']
|
|
decision=gate(tau,last,undefined)
|
|
save(dest/'target-access.json',[dict(case=r['case'],role='fold0_validation',target_sha256=r['v5_cache']['output_sha256']['target.npy']) for r in c['rows']['validation']])
|
|
save(dest/'result.json',dict(status='COMPLETE',decision=decision,parts=len(rows),components=len(groups),metrics=metrics,undefined=undefined,rows=rows,
|
|
interpretation='validation-only one-fold feasibility; capped ranker vs full-tet A does not isolate loss; rank raw score has no physical-time calibration'))
|
|
|
|
|
|
def run(root):
|
|
c=config(root);os.sched_setaffinity(0,[24]);start=time.process_time();u0=resource.getrusage(resource.RUSAGE_CHILDREN);charged=0.;records=[]
|
|
lock=(root/'run.lock').open('a');fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
|
|
dependency=BASE/'artifacts/phase2-h1-labelled-recovery-2026-11-17/complete.json'
|
|
if not dependency.exists() or read(dependency)['status']!='COMPLETE':raise RuntimeError('B1 recovery must complete before B7')
|
|
if (root/'started.json').exists():raise FileExistsError('B7 no retry')
|
|
save(root/'started.json',dict(pid=os.getpid(),unix=time.time(),contract_sha256=sha(root/'contract.json')))
|
|
def total():
|
|
u=resource.getrusage(resource.RUSAGE_CHILDREN);return 60+max(charged,u.ru_utime+u.ru_stime-u0.ru_utime-u0.ru_stime)+time.process_time()-start
|
|
try:
|
|
for mode in ['train','predict','score']:
|
|
if mode=='predict':freeze(root,'model',[root/'contract.json',root/'phases/train/model.ubj',root/'phases/train/result.json',*[BASE/p for p in c['code_sha256']]])
|
|
if mode=='score':freeze(root,'predictions',[root/'contract.json',root/'phases/predict/manifest.json',*[BASE/p for p in c['code_sha256']]])
|
|
dest=root/'phases'/mode;dest.mkdir(parents=True,exist_ok=False);cap=min(c['phase_limits'][mode],7200-total()-120)
|
|
disk_remaining=c['disk_bytes']-disk_usage(root)
|
|
if disk_remaining<=0:raise RuntimeError('B7 cumulative disk cap')
|
|
if cap<=0:raise RuntimeError('B7 cumulative CPU cap')
|
|
save(root/'live-progress.json',dict(stage=mode,unix=time.time(),cumulative_cpu_seconds=total()))
|
|
g=supervise([sys.executable,'tools/phase2_b7_gate.py',mode,str(root)],dest,dict(cpu_seconds=cap,wall_seconds=c['phase_limits'][mode],rss_bytes=c['rss_bytes'],disk_bytes=disk_remaining))
|
|
charged+=g['cpu_seconds'];records.append(dict(phase=mode,guard=g));save(root/'phase-ledger.json',dict(records=records,cumulative_cpu_seconds=total()))
|
|
if g['status']!='PASS' or total()>7200 or disk_usage(root)>c['disk_bytes']:raise RuntimeError('B7 phase/resource stop')
|
|
save(root/'complete.json',dict(status='COMPLETE',cumulative_cpu_seconds=total(),records=records,scientific_gate=read(root/'phases/score/result.json')['decision'],retry=False))
|
|
except BaseException as exc:
|
|
save(root/'complete.json',dict(status='STOPPED',reason=type(exc).__name__+': '+str(exc),cumulative_cpu_seconds=total(),records=records,retry=False));raise
|
|
|
|
|
|
if __name__=='__main__':
|
|
p=argparse.ArgumentParser();p.add_argument('mode',choices=['prepare','run','train','predict','score']);p.add_argument('path',type=Path);a=p.parse_args()
|
|
if a.mode=='prepare':prepare(a.path)
|
|
elif a.mode=='run':run(a.path)
|
|
else:dict(train=train,predict=predict,score=score)[a.mode](a.path,config(a.path))
|