Files
MeltMind/tools/s3b_v04_gates.py

144 lines
8.7 KiB
Python

"""Independent exact-reference and count-only cost gates; no label access."""
import argparse
from pathlib import Path
import time
import traceback
import numpy as np
from scipy.stats import kendalltau
from s3b_runtime import read,sha,checked,restrict_prediction_io
from naive_ordering_math import cdf_interval
from s2_recovery_supervisor import save
def compare_fields(exact,batch):
for key in ['raw_ids','mass']:
if not np.array_equal(exact[key],batch[key]):raise ValueError('Full tet support mismatch: '+key)
n=len(exact['raw_ids'])
for field in [exact,batch]:
if (field['arrival'].shape!=(n,) or field['remaining'].shape!=(n,) or
not np.isfinite(field['arrival']).all() or np.any(field['remaining']!=0)):
raise ValueError('Reference comparison needs all finite full-tet arrivals and zero remaining')
tau=float(kendalltau(exact['arrival'],batch['arrival'],variant='b',nan_policy='raise').statistic)
left_exact,_=cdf_interval(exact['arrival'],exact['mass'])
left_batch,_=cdf_interval(batch['arrival'],batch['mass'])
return dict(status='PASS' if np.isfinite(tau) and tau>=.999 else 'FAIL',nodes=n,
tau_b=tau if np.isfinite(tau) else None,threshold=.999,
max_strict_volume_CDF_delta=float(np.max(abs(left_exact-left_batch))),
exact_unique_arrivals=len(np.unique(exact['arrival'])),batch_unique_arrivals=len(np.unique(batch['arrival'])),
tau_measure='one vote per full tet node',CDF_measure='strict less-than, original full tet mass',
CDF_delta_gate=False,no_solver_switch=True)
def query_count(edges,faces,dw):
n=len(dw)
if not np.isfinite(dw).all() or np.any(dw<0):raise ValueError('Invalid Dw')
e=np.asarray(edges);f=np.asarray(faces)
wall=np.sort(np.concatenate([f[:,[0,1]],f[:,[0,2]],f[:,[1,2]]]),axis=1)
keys=e[:,0].astype(np.int64)*n+e[:,1]
wallkeys=np.unique(wall[:,0].astype(np.int64)*n+wall[:,1])
is_wall=np.isin(keys,wallkeys);both=(dw[e]==0).all(axis=1)
if not both[is_wall].all():raise ValueError('Surface edge does not have zero-Dw endpoints')
return int(np.count_nonzero(both&~is_wall))
def projection_terms(measurements,total_nodes,total_queries,parts):
if len(measurements)!=10 or any(r['status']!='COMPLETE' for r in measurements):
raise ValueError('Ten complete measurements required')
midpoint_rates=[r['costs']['midpoint_CPU_s']/r['exact_midpoint_queries'] for r in measurements if r['exact_midpoint_queries']>0]
if total_queries>0 and not midpoint_rates:raise ValueError('No ten-part positive-query rate evidence')
event_rate=max(r['costs']['events_CPU_s']/r['nodes'] for r in measurements)
midpoint_rate=max(midpoint_rates,default=0.)
# Fixed import/verification/geometry/output overhead is conservatively
# bounded by the largest measured non-event/non-query overhead per part.
overhead=max(max(0.,r['guard_CPU_s']-r['costs']['events_CPU_s']-
(r['costs']['midpoint_CPU_s'] if r['exact_midpoint_queries']>0 else 0.)) for r in measurements)
return dict(max_event_CPU_per_node=event_rate,max_midpoint_CPU_per_query=midpoint_rate,
positive_query_measurements=len(midpoint_rates),max_fixed_overhead_CPU_per_part=overhead,
total_nodes=total_nodes,total_queries=total_queries,parts=parts,
variable_projection_CPU_s=1.25*(event_rate*total_nodes+midpoint_rate*total_queries),
fixed_projection_CPU_s=overhead*parts,margin=1.25,
note='Frozen full617 max-rate screening; includes ten in conservative projection, but winning ten are reused, never rerun.')
def verify_gate_config(root):
c=read(root/'contract.json');f=read(root/'code-freeze.json')
if f['contract_sha256']!=sha(root/'contract.json') or not f['git_commit']:raise ValueError('Gates not Git-frozen')
for p,h in {**c['code_sha256'],**c['source_sha256']}.items():checked(p,h)
return c
def measure(root,kind):
c=verify_gate_config(root);ten=Path(c['ten_root']);tc=read(ten/'contract.json')
terminal=read(ten/'complete.json');chosen=read(ten/'selected-solver.json')
if terminal['status']!='TEN_PASS_AWAITING_REFERENCE_AND_COST' or terminal['selected_solver']!=chosen['method']:
raise ValueError('Ten not fully passed and frozen')
if (Path(c['stage_guard_root'])/'trigger.json').exists():raise ValueError('External stage-cap failure')
method=chosen['method'];dest=root/kind/'output';dest.mkdir(exist_ok=False)
start=time.process_time();allowed=[tc['roster']]
fields=[];results=[];measurements=[]
for i in range(10):
d=ten/'candidates'/method/'parts'/f'part-{i:02d}'
receipt=read(d/'guard-result.json')
if receipt['classification']['category']!='PASS':raise ValueError('Ten receipt not PASS')
p=d/'output/result.json';checked(p,receipt['files']['result']['sha256'])
result=read(p);result['guard_CPU_s']=receipt['worker']['cpu_seconds'];measurements.append(result)
if i<3:
f=d/'output/event-field.npz';fields.append(f)
allowed.append(str(f));results.append(result)
if kind=='reference':
allowed += [r['field'] for r in tc['exact_references']]
restrict_prediction_io(allowed,dest)
rows=[]
for i,ref in enumerate(tc['exact_references']):
row=dict(index=i,case=ref['case'],reference_sha256=ref['field_sha256'],
batch_sha256=results[i]['output_sha256']['event-field.npz'])
try:
checked(ref['field'],ref['field_sha256']);checked(fields[i],row['batch_sha256'])
with np.load(ref['field'],allow_pickle=False) as a,np.load(fields[i],allow_pickle=False) as b:
row.update(compare_fields(a,b))
except Exception as exc:row.update(status='FAIL',type=type(exc).__name__,reason=str(exc))
rows.append(row)
result=dict(status='PASS' if len(rows)==3 and all(r['status']=='PASS' for r in rows) else 'FAIL',
solver=method,parts=rows,large_part_accuracy_verified=False,no_solver_switch=True,
labels_read=False,worker_CPU_s=time.process_time()-start)
save(dest/'result.json',result)
return 0
if kind!='census':raise ValueError('Unknown gate stage')
# This only counts original edges; it does not query distances or solve.
checked(tc['roster'],tc['roster_sha256']);roster=read(tc['roster'])
included=sorted([r for r in roster['parts'] if r['included']],key=lambda r:r['case'])
if [r['case'] for r in included]!=tc['all_cases'] or len(included)!=617:raise ValueError('Roster mismatch')
for r in included:
source=Path(r['preparation']['preparation_root']);allowed += [str(source/'geometry.npz'),str(source/'boundary_distance_raw.npy')]
restrict_prediction_io(allowed,dest)
counts=[]
try:
for row in included:
p=row['preparation'];source=Path(p['preparation_root'])
for name in ['geometry.npz','boundary_distance_raw.npy']:checked(source/name,p['output_sha256'][name])
dw=np.load(source/'boundary_distance_raw.npy',allow_pickle=False)
with np.load(source/'geometry.npz',allow_pickle=False) as z:
edges=z['edges'];faces=z['boundary_triangles'];raw=z['raw_node_ids']
if len(raw)!=row['nodes'] or len(dw)!=len(raw):raise ValueError('Node count differs')
count=query_count(edges,faces,dw)
counts.append(dict(case=row['case'],nodes=row['nodes'],exact_midpoint_queries=count,
geometry_sha256=p['output_sha256']['geometry.npz'],dw_sha256=p['output_sha256']['boundary_distance_raw.npy']))
save(dest/'progress.json',dict(parts=len(counts),worker_CPU_s=time.process_time()-start))
save(dest/'counts.json',dict(parts=counts,labels_read=False,distances_queried=0))
bycase={r['case']:r for r in counts}
for r in measurements:
if bycase[r['case']]['exact_midpoint_queries']!=r['exact_midpoint_queries']:raise ValueError('Census/ten query count differs')
terms=projection_terms(measurements,sum(r['nodes'] for r in counts),sum(r['exact_midpoint_queries'] for r in counts),len(counts))
save(dest/'result.json',dict(status='COMPLETE',projection_terms=terms,counts_sha256=sha(dest/'counts.json'),
labels_read=False,distances_queried=0,worker_CPU_s=time.process_time()-start))
return 0
except Exception as exc:
save(dest/'failure.json',dict(type=type(exc).__name__,reason=str(exc),traceback=traceback.format_exc(),
complete_parts=counts,worker_CPU_s=time.process_time()-start))
raise
if __name__=='__main__':
p=argparse.ArgumentParser();p.add_argument('root',type=Path);p.add_argument('kind',choices=['reference','census'])
a=p.parse_args();raise SystemExit(measure(a.root,a.kind))