197 lines
12 KiB
Python
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()
|