"""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))