88 lines
5.3 KiB
Python
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)
|