Files
MeltMind/tools/run_s3b_part.py
T

98 lines
5.9 KiB
Python

"""One immutable geometry-only exact-event measurement. Never reads labels."""
import argparse
import json
import os
from pathlib import Path
import time
import traceback
import numpy as np
from s2_recovery_supervisor import save
from s3b_runtime import contract, checked, read, sha, restrict_prediction_io
from s3b_graph import SOLVER, edge_geometry, distal_regions, fill_events
def run(root, index):
c = contract(root); spec = c['ten_parts'][index]
dest = root/'parts'/f'part-{index:02d}'/'output'; dest.mkdir(exist_ok=False)
save(dest/'started.json', dict(pid=os.getpid(), case=spec['case'], index=index, unix=time.time(),
solver=SOLVER, authorizing_ruling=c['authorizing_ruling'], labels_read=False))
allowed = list(spec['inputs'])
restrict_prediction_io(allowed, dest)
start = time.monotonic(); cpu = time.process_time(); latest = None
cost = {}; geometry = None
def progress(stage, **kw):
save(dest/'progress.json', dict(stage=stage, case=spec['case'], pid=os.getpid(), unix=time.time(),
worker_CPU_s=time.process_time()-cpu, wall_s=time.monotonic()-start, **kw))
try:
progress('VERIFY_GEOMETRY_ALLOWLIST')
for p, h in spec['inputs'].items(): checked(p, h)
source = Path(spec['preparation_root'])
metadata = read(source/'result.json')
if metadata['base_columns'][5] != 'geodesic_over_Rg':
raise ValueError('Not the original unrestricted geodesic column')
with np.load(source/'geometry.npz', allow_pickle=False) as z:
x=z['points_raw']; tetra=z['tetra']; faces=z['boundary_triangles']
edges=z['edges']; mass=z['node_volume_raw']; raw=z['raw_node_ids']; gate=z['gate_location_raw']
dw = np.load(source/'boundary_distance_raw.npy', allow_pickle=False)
base = np.load(source/'base.npy', allow_pickle=False)
distance = base[:, 5]*metadata['scales']['Rg']; del base
if np.any(np.diff(raw) <= 0): raise ValueError('Original IDs must be increasing')
seed = int(np.argmin(np.linalg.norm(x-gate, axis=1)))
if seed != metadata['base_gate_node']: raise ValueError('Gate source identity differs')
branch_start = time.process_time()
regions = distal_regions(distance, mass, edges, raw)
save(dest/'regions.json', dict(case=spec['case'], definition='strict-geodesic-distal-v0.3',
total_volume=float(mass.sum()), geometry_inputs=spec['inputs'], **regions))
cost['regions_CPU_s'] = time.process_time()-branch_start
def midpoint_progress(done, total):
progress('EXACT_MIDPOINTS', completed=done, total=total)
progress('GEOMETRY_EDGE_CAPACITY')
geometry = edge_geometry(x, tetra, faces, dw, edges, mass, midpoint_progress)
cost.update({k:geometry[k] for k in ['geometry_CPU_s','midpoint_CPU_s']})
np.savez_compressed(dest/'conductance.npz', edges=edges, edge_volume=geometry['edge_volume'],
midpoint_distance=geometry['midpoint'], g=geometry['conductance'],
exact_query_edge_ids=geometry['exact_query_edge_ids'], boundary_edges=geometry['boundary_edges'])
save(dest/'geometry-freeze.json', dict(case=spec['case'], nodes=len(x), total_volume=float(mass.sum()),
exact_midpoint_queries=len(geometry['exact_query_edge_ids']), seed=seed, raw_seed=int(raw[seed]),
boundary_edges=int(geometry['boundary_edges'].sum()), positive_edges=int((geometry['conductance']>0).sum()),
regions_sha256=sha(dest/'regions.json'), conductance_sha256=sha(dest/'conductance.npz'), costs=cost))
progress('EXACT_EVENTS', nodes=len(x), events=0, wetted_nodes=1)
last_progress = -1.
event_start = time.process_time()
with (dest/'events.jsonl').open('x', buffering=1) as stream:
def event(row):
stream.write(json.dumps(row, allow_nan=False)+'\n')
def state(row, remaining, arrival):
nonlocal latest, last_progress
latest = (row, remaining, arrival)
now = time.monotonic()
if row['events'] <= 2 or now-last_progress >= 1:
progress('EXACT_EVENTS', event_state=row)
last_progress = now
arrival, remaining, result = fill_events(edges, geometry['conductance'], mass, seed, event, state)
cost['events_CPU_s'] = time.process_time()-event_start
np.savez_compressed(dest/'event-field.npz', raw_ids=raw, arrival=arrival, remaining=remaining, mass=mass)
save(dest/'result.json', dict(case=spec['case'], index=index, nodes=len(x),
exact_midpoint_queries=len(geometry['exact_query_edge_ids']), **result, costs=cost,
labels_read=False, GPU=False, new_fits=0, event_batching=False, solver=SOLVER,
worker_CPU_s=time.process_time()-cpu, wall_s=time.monotonic()-start,
output_sha256={p.name:sha(p) for p in dest.iterdir() if p.is_file() and p.name!='progress.json'}))
progress(result['status'], event_state=result)
return 0
except Exception as exc:
if latest is not None:
state, remaining, arrival = latest
np.savez_compressed(dest/'last-trusted-state.npz', remaining=remaining, arrival=arrival)
else: state = None
save(dest/'failure.json', dict(status='NUMERICAL_OR_INPUT_FAILURE', case=spec['case'],
type=type(exc).__name__, message=str(exc), traceback=traceback.format_exc(),
last_trusted_state=state, remaining_volume=state['remaining_volume'] if state else None,
remaining_state='KNOWN_LAST_STATE' if state else 'UNKNOWN', costs=cost,
worker_CPU_s=time.process_time()-cpu, wall_s=time.monotonic()-start, retry=False))
raise
if __name__ == '__main__':
parser=argparse.ArgumentParser();parser.add_argument('root', type=Path);parser.add_argument('index', type=int)
args=parser.parse_args();raise SystemExit(run(args.root,args.index))