Files
MeltMind/tools/phase2_b7_gate.py

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