Files
MeltMind/tools/run_e6_real_kernel.py
T

197 lines
12 KiB
Python

"""Bounded E6: physical-radius kernel on cached real geometry, no graph smoothing.
Anchor estimates describe the positive-distance LUMPED discrete measure, not
continuous full-cavity volume. Boundary lumped mass is explicitly unscored.
"""
import argparse
import hashlib
import json
from pathlib import Path
import resource
import time
import numpy as np
from scipy.spatial import cKDTree
if __package__:
from .run_volume_quadrature_trial import tetra_rule
from .projector_remesh_probe import grouped
else:
from run_volume_quadrature_trial import tetra_rule
from projector_remesh_probe import grouped
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def save(path, value):
Path(path).write_text(json.dumps(value, indent=2, allow_nan=False)+'\n')
def quantiles(a):
return dict(zip(['min','p50','p99','max'], map(float,np.quantile(a,[0,.5,.99,1]))))
def anchor_plan(d, mass, seed, n):
order=np.argsort(d,kind='stable')
median=float(d[order[np.searchsorted(np.cumsum(mass[order]),mass.sum()/2)]])
if median<=0: raise ValueError('Nonpositive thickness proxy; do not silently choose R')
positive=np.flatnonzero(d>0)
draws=np.random.default_rng(seed).choice(positive,size=n,replace=True,p=mass[positive]/mass[positive].sum())
unique,inverse=np.unique(draws,return_inverse=True)
return unique,inverse,dict(weighted_median_distance=median,thickness_proxy=4*median,radius=10*median,
positive_distance_mass_fraction=float(mass[positive].sum()/mass.sum()),
boundary_unscored_mass_fraction=float(mass[d==0].sum()/mass.sum()),
draws=n,unique_anchors=len(unique),seed=seed)
def raw_field(x,tet,d):
"""Same pre-smoothing tensor definition as node_tensor(steps=0), batched."""
total=np.zeros((len(x),3,3));supported_mass=np.zeros(len(x));bad=0
for begin in range(0,len(tet),8192):
ids=tet[begin:begin+8192];p=x[ids];edge=p[:,1:]-p[:,:1]
v=abs(np.linalg.det(edge))/6
if np.any(v<=0): raise ValueError('Degenerate tetrahedron')
g=np.linalg.solve(edge,(d[ids[:,1:]]-d[ids[:,:1]])[...,None])[...,0]
norm=np.linalg.norm(g,axis=1);ok=norm>1e-8;bad+=int((~ok).sum())
normal=g/np.where(ok,norm,1)[:,None]
outer=normal[:,:,None]*normal[:,None,:]
w=v*ok/4
for j in range(4):
np.add.at(total,ids[:,j],outer*w[:,None,None]);np.add.at(supported_mass,ids[:,j],w)
total/=np.where(supported_mass>0,supported_mass,1)[:,None,None]
return total,dict(zero_gradient_tets=bad,unsupported_nodes=int((supported_mass==0).sum()),smoothing_steps=0)
def samples(x,tet,mass,rule,raw=None):
if rule=='lumped_vertex': return x,mass,raw
if rule!='tetra_four_point': raise ValueError(rule)
sx=np.empty((4*len(tet),3));sm=np.empty(4*len(tet))
st=None if raw is None else np.empty((4*len(tet),3,3))
bary=tetra_rule()
for begin in range(0,len(tet),8192):
ids=tet[begin:begin+8192];p=x[ids];sl=slice(4*begin,4*(begin+len(ids)))
sx[sl]=np.einsum('qj,tjk->tqk',bary,p).reshape(-1,3)
sm[sl]=np.repeat(abs(np.linalg.det(p[:,1:]-p[:,:1]))/24,4)
if st is not None: st[sl]=np.einsum('qj,tjkl->tqkl',bary,raw[ids]).reshape(-1,3,3)
if not np.isclose(sm.sum(),mass.sum(),rtol=1e-10): raise ValueError('Mass mismatch')
return sx,sm,st
def integrate(query,sx,sm,st,radius):
tree=cKDTree(sx);n=len(query);tensor=np.zeros((n,3,3));km=np.zeros(n);neff=np.zeros(n);cov=np.zeros((n,3))
for i,q in enumerate(query):
ids=np.asarray(tree.query_ball_point(q,radius),dtype=int)
delta=sx[ids]-q;w=sm[ids]*np.maximum(1-np.sum(delta*delta,axis=1)/radius**2,0)**2
good=w>0;ids=ids[good];delta=delta[good];w=w[good]
if not len(w): continue
km[i]=w.sum();wn=w/km[i];neff[i]=1/(wn@wn)
tensor[i]=np.einsum('i,ijk->jk',wn,st[ids])
mean=wn@delta;cc=(delta*wn[:,None]).T@delta-np.outer(mean,mean)
val=np.linalg.eigvalsh(cc)[::-1]
cov[i]=val/max(val[0],1e-30)
return dict(tensor=tensor,kernel_mass=km,effective_samples=neff,
ball_mass_ratio=km/(32*np.pi*radius**3/105),position_covariance_eigenvalue_ratios=cov)
def proportion(mask):
"""Wilson interval for independent with-replacement probability draws."""
n=len(mask);p=float(np.mean(mask));z=1.959963984540054
center=(p+z*z/(2*n))/(1+z*z/n)
delta=z*np.sqrt(p*(1-p)/n+z*z/(4*n*n))/(1+z*z/n)
return dict(estimate=p,mc_wilson95=[max(0.,center-delta),min(1.,center+delta)])
def summary(a,inverse,fraction):
f=grouped(a['tensor'],.1);code=f['code'][inverse]
value=f['values'];gap=(value[:,:-1]-value[:,1:])/np.maximum(value[:,:1],1e-12)
defined=(~f['unsupported'])[inverse];neff=(a['effective_samples']>=64)[inverse]
mode={str(k):proportion(code==k) for k in [-1,0,1,2,3]}
for item in mode.values(): item['full_lumped_mass_contribution']=fraction*item['estimate']
near=((gap>=.05)&(gap<=.15))[inverse]&defined[:,None]
return dict(measure='Conditional positive-distance lumped-node volume; MC estimate, NOT continuous full-cavity volume',
modes=mode,near_cut={k:proportion(v) for k,v in [('gap12',near[:,0]),('gap23',near[:,1]),('either',near.any(1))]},
neff_gate_pass=proportion(neff),neff_failed=proportion(~neff),
neff_pass_mode_contributions={str(k):proportion(neff&(code==k)) for k in [-1,0,1,2,3]},
neff_pass_directionally_grouped=proportion(neff&np.isin(code,[1,2,3])),
spectrally_defined=proportion(defined),effective_samples=quantiles(a['effective_samples'][inverse]),
ball_mass_ratio=quantiles(a['ball_mass_ratio'][inverse]),
covariance_ratios=[quantiles(a['position_covariance_eigenvalue_ratios'][inverse,j]) for j in range(3)],
physical_support_quality_pass=None,continuous_volume_accuracy_certified=False,
interval_scope='Sampling uncertainty only; excludes geometry, quadrature, distance and discretization errors.')
def pose_comparison(a,b,query,gate,R,shift,inverse):
f=grouped(a['tensor'],.1);g=grouped(b['tensor'],.1);same=f['code']==g['code']
ok=same&np.isin(f['code'],[1,2,3]);v=gate-query
vp=(gate@R.T+shift)-(query@R.T+shift)
av=np.einsum('ngij,nj->ngi',f['projector'],v);bv=np.einsum('ngij,nj->ngi',g['projector'],vp)
return dict(independent_recomputed_mesh_gradients_and_kernel=True,cached_scalar_distance_reused_under_rigid_motion=True,
model_prediction_check=False,tensor_covariance_max=float(abs(b['tensor']-R@a['tensor']@R.T).max()),
mode_flip=proportion((~same)[inverse]),neff_gate_flip=proportion(((a['effective_samples']>=64)!=(b['effective_samples']>=64))[inverse]),
compatible_directional_anchor_count=int(ok.sum()),
grouped_projector_covariance_max=float(np.linalg.norm((g['projector']-R@f['projector']@R.T)[ok],axis=(2,3)).max(initial=0)),
projected_gate_vector_covariance_max_raw=float(np.linalg.norm((bv-av@R.T)[ok],axis=2).max(initial=0)),
gate_distance_error_max_raw=float(abs(np.linalg.norm(vp,axis=1)-np.linalg.norm(v,axis=1)).max()),
kernel_mass_relative_change_max=float((abs(b['kernel_mass']-a['kernel_mass'])/np.maximum(a['kernel_mass'],1e-30)).max()))
def main():
p=argparse.ArgumentParser();p.add_argument('phase',choices=['preflight','run']);p.add_argument('output',type=Path);args=p.parse_args();out=args.output
contract=json.loads((out/'execution_contract.json').read_text())
for path,h in contract['input_sha256'].items():
if sha(path)!=h: raise ValueError('Changed source '+path)
with (out/(args.phase+'.started.json')).open('x') as f: json.dump({'contract_sha256':sha(out/'execution_contract.json')},f)
started=time.monotonic();rows=[]
if args.phase=='run':
pre=json.loads((out/'preflight.json').read_text())
if pre['contract_sha256']!=sha(out/'execution_contract.json'): raise ValueError('Preflight contract changed')
R,_=np.linalg.qr(np.random.default_rng(421).normal(size=(3,3)));R*=np.linalg.det(R);shift=np.array([3.1,-7.,2.])
for spec in contract['cases']:
tick=time.monotonic();case=spec['case'];print(args.phase,case,flush=True)
data=np.load(spec['sample']);x=data['points_raw'];tet=data['tetra'];mass=data['node_volume_raw'];d=np.load(spec['distance']);gate=data['gate_location_raw']
unique,inverse,plan=anchor_plan(d,mass,spec['seed'],contract['draws']);radius=plan['radius'];query=x[unique]
if args.phase=='run':
raw,raw_meta=raw_field(x,tet,d);xr=x@R.T+shift;rawr,rawr_meta=raw_field(xr,tet,d)
with np.load(spec['tensor_cache']) as cached:
baseline=grouped(cached['tensor'][unique],.1)
bv=baseline['values'];bg=(bv[:,:-1]-bv[:,1:])/np.maximum(bv[:,:1],1e-12)
bn=((bg>=.05)&(bg<=.15))[inverse]&(~baseline['unsupported'])[inverse,None]
matched_baseline=dict(field='cached_3hop_at_IDENTICAL_anchors_and_measure',
modes={str(k):proportion(baseline['code'][inverse]==k) for k in [-1,0,1,2,3]},
near_cut_either=proportion(bn.any(1)))
for rule in spec['rules']:
name=case+'_'+rule
if args.phase=='preflight':
sx,sm,_=samples(x,tet,mass,rule);tree=cKDTree(sx)
counts=tree.query_ball_point(query,radius,return_length=True)
p99_budget=float(np.quantile(counts[inverse],.99)*len(inverse));actual=int(counts.sum())
guard=p99_budget<=contract['evaluation_budget'] and 2*actual<=contract['evaluation_budget']
row=dict(name=name,case=case,rule=rule,plan=plan,source_samples=len(sx),neighbors=quantiles(counts[inverse]),
p99_times_draws=p99_budget,unique_neighbor_sum=actual,main_plus_pose_evaluation_upper_bound=2*actual,guard_pass=bool(guard))
np.savez_compressed(out/(name+'_anchors.npz'),unique_node_ids=unique,draw_to_unique=inverse,neighbor_counts=counts)
del tree,sx,sm
else:
previous=next(r for r in pre['cases'] if r['name']==name)
if not previous['guard_pass']:
rows.append(dict(name=name,status='NOT_RUN_COST_GUARD'));continue
anchors=np.load(out/(name+'_anchors.npz'))
if not np.array_equal(anchors['unique_node_ids'],unique) or not np.array_equal(anchors['draw_to_unique'],inverse): raise ValueError('Anchors changed')
sx,sm,st=samples(x,tet,mass,rule,raw);a=integrate(query,sx,sm,st,radius);del sx,sm,st
sx,sm,st=samples(xr,tet,mass,rule,rawr);b=integrate(query@R.T+shift,sx,sm,st,radius);del sx,sm,st
np.savez_compressed(out/(name+'_fields.npz'),unique_node_ids=unique,draw_to_unique=inverse,
**{'original_'+k:v for k,v in a.items()},**{'rotated_'+k:v for k,v in b.items()})
row=dict(name=name,status='COMPUTED',case=case,rule=rule,plan=plan,raw_field=raw_meta,rotated_raw_field=rawr_meta,
statistics=summary(a,inverse,plan['positive_distance_mass_fraction']),
matched_old_baseline=matched_baseline,
pose=pose_comparison(a,b,query,gate,R,shift,inverse),new_kernel_estimates=2)
row['case_elapsed_seconds_so_far']=time.monotonic()-tick
save(out/(name+'_'+args.phase+'.json'),row);rows.append(row);print('DONE',name,flush=True)
del data,x,tet,mass,d,gate
result=dict(phase=args.phase,contract_sha256=sha(out/'execution_contract.json'),cases=rows,wall_seconds=time.monotonic()-started,
peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,training=False,O1=False,O2A=False,O2B=False,O2S=False,
scope='E6 bounded estimator diagnostics; no predictive or physical-support acceptance claim')
save(out/(args.phase+'.json'),result)
if __name__=='__main__': main()