Files
MeltMind/tools/phase2_b11_math.py

88 lines
5.3 KiB
Python

"""Full dry-H0 bars and marker reconstruction, independent of pinned B1 code."""
import heapq
import math
import time
import numpy as np
def full_bars(field,mass,raw,adjacency):
s=np.asarray(field,dtype=np.float64);m=np.asarray(mass,dtype=np.float64);raw=np.asarray(raw);n=len(s)
if s.shape!=m.shape or raw.shape!=s.shape or adjacency.shape!=(n,n) or not n:raise ValueError('Bar domain mismatch')
if not np.isfinite(s).all() or not np.isfinite(m).all() or np.any(m<=0) or len(np.unique(raw))!=n:raise ValueError('Invalid bar input')
order=np.argsort(-s,kind='stable');bounds=np.r_[0,np.flatnonzero(np.diff(s[order])!=0)+1,n]
parent=np.arange(n);active=np.zeros(n,bool);birth=np.zeros(n);birth_id=raw.copy();records={}
def find(i):
while parent[i]!=i:parent[i]=parent[parent[i]];i=int(parent[i])
return i
total=math.fsum(map(float,m));passed=0.
for lo,hi in zip(bounds[:-1],bounds[1:]):
layer=order[lo:hi];level=passed/total;pending=set(map(int,layer));blocks=[]
while pending:
first=next(iter(pending));pending.remove(first);todo=[first];nodes=[];old=set()
while todo:
i=todo.pop();nodes.append(i)
for jj in adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]:
j=int(jj)
if active[j]:old.add(find(j))
elif j in pending:pending.remove(j);todo.append(j)
blocks.append((nodes,old))
bp=list(range(len(blocks)));owner={}
def bf(i):
while bp[i]!=i:bp[i]=bp[bp[i]];i=bp[i]
return i
for k,(_,old) in enumerate(blocks):
for g in old:
if g in owner:bp[bf(k)]=bf(owner[g])
else:owner[g]=k
compound={}
for k in range(len(blocks)):compound.setdefault(bf(k),[]).append(k)
for keys in compound.values():
nodes=[i for k in keys for i in blocks[k][0]];olds=set().union(*(blocks[k][1] for k in keys))
if olds:
survivor=min(olds,key=lambda i:(birth[i],int(birth_id[i])))
for g in sorted(olds-{survivor},key=lambda i:(birth[i],int(birth_id[i]))):
records[g].update(death=float(level),persistence=float(level-birth[g]),infinite=False)
for g in olds:parent[g]=survivor
else:
survivor=min(nodes,key=lambda i:int(raw[i]));birth[survivor]=level;birth_id[survivor]=raw[survivor]
records[survivor]=dict(birth=float(level),birth_raw_id=int(raw[survivor]),birth_nodes=sorted(nodes,key=lambda i:int(raw[i])),
birth_raw_ids=sorted(map(int,raw[nodes])),birth_value=float(s[survivor]),death=None,persistence=None,infinite=True)
for i in nodes:parent[i]=survivor;active[i]=True
passed=math.fsum((passed,math.fsum(map(float,m[layer]))))
roots={find(i) for i in range(n)}
if {k for k,v in records.items() if v['infinite']}!=roots:raise ValueError('Infinite class identity mismatch')
return dict(bars=sorted(records.values(),key=lambda r:(r['birth'],r['birth_raw_id'])),infinite_classes=len(roots),nodes=n,total_mass=total)
def reconstruct(field,mass,raw,adjacency,threshold=.020):
start=time.process_time();s=np.asarray(field,dtype=np.float64);detail=full_bars(s,mass,raw,adjacency)
extracted=time.process_time()
markers=[]
for bar in detail['bars']:
bar['kept']=bar['infinite'] or bar['persistence']>=threshold
if bar['kept']:markers.extend(bar['birth_nodes'])
clean=np.full(len(s),-np.inf);heap=[]
for i in markers:clean[i]=s[i];heapq.heappush(heap,(-float(s[i]),int(i)))
while heap:
negative,i=heapq.heappop(heap);value=-negative
if value!=clean[i]:continue
for jj in adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]:
j=int(jj);candidate=min(value,float(s[j]))
if candidate>clean[j]:clean[j]=candidate;heapq.heappush(heap,(-candidate,j))
if not np.isfinite(clean).all() or np.any(clean>s) or not np.array_equal(clean[markers],s[markers]):raise ValueError('Reconstruction invariant failed')
detail.update(threshold=threshold,marker_nodes=sorted(markers),changed_nodes=int(np.count_nonzero(clean!=s)),
extraction_cpu_seconds=extracted-start,reconstruction_cpu_seconds=time.process_time()-extracted)
return clean,detail
def gate_decision(raw,clean,metric_pairs,parts,failures):
values=[raw.get('precision'),clean.get('precision'),raw.get('recall'),clean.get('recall')]
if parts!=50 or failures or any(x is None for x in values):return dict(decision='PARK_UNDEFINED_OR_COVERAGE')
if any(not pairs for pairs in metric_pairs.values()):return dict(decision='PARK_UNDEFINED_OR_COVERAGE')
if any(len(pairs)!=50 for pairs in metric_pairs.values()):return dict(decision='PARK_UNDEFINED_OR_COVERAGE')
last=float(np.mean([b-a for a,b in metric_pairs['last_location']]))
tau=float(np.mean([a-b for a,b in metric_pairs['kendall_tau_b']]))
changes=dict(precision_gain=clean['precision']-raw['precision'],recall_loss=raw['recall']-clean['recall'],last_distance_increase=last,tau_b_loss=tau)
passed=changes['precision_gain']>=.010 and changes['recall_loss']<=.020 and last<=.010 and tau<=.010
return dict(decision='RETAIN_FOR_INDEPENDENT_PANEL' if passed else 'PRUNE_THIS_FIXED_RULE_ON_THIS_ARM',changes=changes)