Files
MeltMind/tools/o2_rep.py
T

67 lines
4.3 KiB
Python

"""Frozen O2-rep v1.1 + v1.1a FP64 readout. No learned or physical type labels."""
import numpy as np
TAU_MIN=1e-10
EPS_PSD=1e-12
EDGE_REL=1e-12
GATE_REL=1e-6
STATUS={0:'valid',1:'unscored',2:'invalid_kernel_mass',3:'invalid_tensor',4:'invalid_trace',5:'invalid_psd'}
TAU_REASON={0:'defined',1:'unscored',2:'no_positive_finite_kernel_mass',3:'tensor_missing_or_nonfinite',4:'trace_nonfinite'}
DIRECTION_REASON={0:'defined',1:'missing_L_med',2:'vector_nonfinite',3:'at_or_below_length_tolerance'}
def readout(tensor,kernel_mass,scored,neff):
t=np.asarray(tensor,dtype=np.float64);w=np.asarray(kernel_mass);scored=np.asarray(scored,bool);n=len(w)
if t.shape!=(n,3,3):raise ValueError('Expected one 3x3 tensor per anchor')
status=np.ones(n,np.uint8);reason=np.ones(n,np.uint8);tau0=np.full(n,np.nan);taup=np.full(n,np.nan)
values=np.full((n,3),np.nan);mu=np.zeros((n,3));g=np.zeros((n,2));B=np.zeros((n,2,3,3));corrected=np.zeros((n,3,3));clipped=np.zeros(n,bool)
positive=scored&np.isfinite(w)&(w>0);status[scored&~positive]=2;reason[scored&~positive]=2
finite=positive&np.isfinite(t).all((1,2));status[positive&~finite]=3;reason[positive&~finite]=3
with np.errstate(over='ignore',invalid='ignore'):trace=np.trace(t,axis1=1,axis2=2)
defined=finite&np.isfinite(trace);tau0[defined]=trace[defined];reason[defined]=0
status[finite&~defined]=4;reason[finite&~defined]=4
eligible=defined&(trace>TAU_MIN);status[defined&~eligible]=4
ids=np.flatnonzero(eligible)
if len(ids):
v,U=np.linalg.eigh(.5*t[ids]+.5*t[ids].transpose(0,2,1));v=v[:,::-1];U=U[:,:,::-1];values[ids]=v
psd=v[:,-1]>=-EPS_PSD*tau0[ids];status[ids[~psd]]=5
good=ids[psd];v=v[psd];U=U[psd];status[good]=0;clipped[good]=(v<0).any(1)
vp=np.maximum(v,0);taup[good]=vp.sum(1);m=vp/taup[good,None];mu[good]=m;gg=m[:,:-1]-m[:,1:];g[good]=gg
P1=U[:,:,0,None]*U[:,None,:,0];P3=U[:,:,2,None]*U[:,None,:,2]
B[good,0]=gg[:,0,None,None]*P1
B[good,1]=gg[:,1,None,None]*(np.eye(3)-P3)
# Exact repeated gaps yield an exact zero, never a chosen axis channel.
corrected[good]=(U*m[:,None,:])@U.transpose(0,2,1)
h=(values[:,:-1]-values[:,1:])/np.maximum(values[:,:1],1e-12)
historical=np.full(n,-1,np.int8);historical[~scored]=-2
historical[eligible]=(h[eligible,0]>.1).astype(np.int8)+2*(h[eligible,1]>.1).astype(np.int8)
return dict(tau0=tau0,tau0_reason=reason,tau_plus=taup,status=status,valid=status==0,clipped=clipped,
neff_pass=np.isfinite(neff)&(np.asarray(neff)>=64),mu=mu,g=g,B=B,normalized_corrected=corrected,
raw_eigenvalues=values,historical_h=h,historical_mode=historical)
def directions(vectors,L_med,kind):
if kind not in ['edge','gate']:raise ValueError('Unknown direction kind')
v=np.asarray(vectors,dtype=np.float64);length=np.linalg.norm(v,axis=-1);unit=np.zeros_like(v);reason=np.ones(length.shape,np.uint8)
if L_med is None or not np.isfinite(L_med) or L_med<=0:
return dict(length=length,unit=unit,valid=np.zeros(length.shape,bool),reason=reason)
finite=np.isfinite(v).all(-1)&np.isfinite(length);reason[~finite]=2
valid=finite&(length>(EDGE_REL if kind=='edge' else GATE_REL)*L_med)
reason[finite&~valid]=3;reason[valid]=0;unit[valid]=v[valid]/length[valid,None]
return dict(length=length,unit=unit,valid=valid,reason=reason)
def contract_direction(B,mu,spectral_valid,vectors,L_med,kind):
d=directions(vectors,L_med,kind);ok=d['valid']&np.asarray(spectral_valid,bool)
q=np.einsum('ni,nkij,nj->nk',d['unit'],B,d['unit']);q[~ok]=0
return dict(q=q,direction_valid=d['valid'],channel_valid=ok,length=d['length'],direction_reason=d['reason'])
def acceptance(r):
ok=r['valid'];B=r['B'][ok];mu=r['mu'][ok];g=r['g'][ok]
if not len(mu):return dict(valid_count=0,mu_sum_error=0.,mu_min=None,ordering_violation=0.,B_symmetry_error=0.,B_min_eigenvalue=None,reconstruction_max=0.)
recon=mu[:,2,None,None]*np.eye(3)+B.sum(1)
return dict(valid_count=int(ok.sum()),mu_sum_error=float(abs(mu.sum(1)-1).max()),mu_min=float(mu.min()),
ordering_violation=float(np.maximum(-g,0).max()),B_symmetry_error=float(abs(B-B.transpose(0,1,3,2)).max()),
B_min_eigenvalue=float(np.linalg.eigvalsh(B).min()),reconstruction_max=float(abs(recon-r['normalized_corrected'][ok]).max()))