Files
MeltMind/tools/review_partition_scale.py

112 lines
9.7 KiB
Python

"""Bounded O1 review: region volume scale, unchanged matching, controlled ablations."""
import argparse
import hashlib
import heapq
import json
from pathlib import Path
import resource
import time
import numpy as np
from scipy.sparse.csgraph import connected_components
if __package__:
from .route_feasibility import graph_from_edges,farthest_seeds,connected_voronoi,partition_report,matched_acceptance
else:
from route_feasibility import graph_from_edges,farthest_seeds,connected_voronoi,partition_report,matched_acceptance
def regions(kind,edges,mass):
selected=edges[kind[edges[:,0]]==kind[edges[:,1]]]
count,labels=connected_components(graph_from_edges(len(kind),selected),directed=False)
volume=np.bincount(labels,weights=mass,minlength=count)
first=np.full(count,len(kind),dtype=int);np.minimum.at(first,labels,np.arange(len(kind)))
return labels,volume,kind[first]
def region_stats(kind,edges,mass):
labels,volume,types=regions(kind,edges,mass)
return dict(regions=len(volume),total_volume_raw=float(mass.sum()),volume_share_by_type=(np.bincount(kind,weights=mass,minlength=4)/mass.sum()).tolist(),region_volume_quantiles=np.quantile(volume,[0,.1,.5,.9,1]).tolist(),region_volumes_raw=volume.tolist(),region_types=types.tolist())
def merge_small_regions(kind,edges,length,mass,min_volume):
labels,volume,types=regions(kind,edges,mass);nr=len(volume);parent=np.arange(nr);contacts=[{} for _ in range(nr)]
crossing=labels[edges[:,0]]!=labels[edges[:,1]]
pairs=np.sort(labels[edges[crossing]],axis=1)
contact_weight=(mass[edges[crossing,0]]+mass[edges[crossing,1]])/(2*length[crossing]**2)
if len(pairs):
unique,index=np.unique(pairs,axis=0,return_inverse=True);weight=np.bincount(index,weights=contact_weight)
for (i,j),w in zip(unique,weight):contacts[i][int(j)]=float(w);contacts[j][int(i)]=float(w)
heap=[(float(v),i) for i,v in enumerate(volume) if v<min_volume];heapq.heapify(heap);history=[]
while heap:
value,i=heapq.heappop(heap)
if parent[i]!=i or value!=volume[i] or value>=min_volume:continue
if not contacts[i]:raise ValueError('Small isolated component: cannot merge without violating topology')
j=min(contacts[i],key=lambda x:(-contacts[i][x],x))
history.append(dict(source=i,destination=j,source_volume=float(volume[i]),destination_volume_before=float(volume[j]),source_type=int(types[i]),destination_type=int(types[j])))
parent[i]=j;volume[j]+=volume[i]
for neighbor,w in list(contacts[i].items()):
contacts[neighbor].pop(i,None)
if neighbor==j:continue
contacts[j][neighbor]=contacts[j].get(neighbor,0.)+w;contacts[neighbor][j]=contacts[neighbor].get(j,0.)+w
contacts[i].clear()
if volume[j]<min_volume:heapq.heappush(heap,(float(volume[j]),j))
def root(i):
while parent[i]!=i:parent[i]=parent[parent[i]];i=parent[i]
return i
roots=np.array([root(i) for i in range(nr)]);cleaned=types[roots[labels]]
_,final_volume,_=regions(cleaned,edges,mass)
if np.any(final_volume<min_volume*(1-1e-12)):raise AssertionError('Minimum-region volume not achieved')
return cleaned,dict(merges=len(history),history=history,changed_nodes=int((cleaned!=kind).sum()),changed_volume_fraction=float(mass[cleaned!=kind].sum()/mass.sum()),minimum_region_volume_raw=float(min_volume))
def histogram_control(weights,length,seed=811,bins=20):
"""Permute actual edge costs within length strata; exact global cost multiset."""
rng=np.random.default_rng(seed);order=np.argsort(length,kind='stable');control=weights.copy()
for ids in np.array_split(order,bins):control[ids]=weights[ids[rng.permutation(len(ids))]]
if not np.array_equal(np.sort(weights),np.sort(control)):raise AssertionError('Changed cost distribution')
return control
def main():
p=argparse.ArgumentParser();p.add_argument('case');p.add_argument('output',type=Path);a=p.parse_args()
out=a.output/a.case;out.mkdir(parents=True,exist_ok=True)
if (out/'result.json').exists() or (out/'scale_contract.json').exists():raise FileExistsError('Preserve existing review run')
previous=Path('artifacts/routes-2026-11-13');sample=Path('artifacts/intake-2026-11-13/samples')/(a.case+'.npz')
data=np.load(sample);saved=np.load(previous/(a.case+'.route_arrays.npz'));old=json.loads((previous/(a.case+'.routes.json')).read_text())
x=data['points_raw'];edges=data['edges'];mass=data['node_volume_raw'];kind=saved['type_proxy'];length=np.linalg.norm(x[edges[:,0]]-x[edges[:,1]],axis=1);graph=graph_from_edges(len(x),edges,length)
start=time.monotonic();before=region_stats(kind,edges,mass);minimum=mass.sum()/512
cleaned,merges=merge_small_regions(kind,edges,length,mass,minimum);after=region_stats(cleaned,edges,mass)
nominal=.5*after['region_volume_quantiles'][2];k=max(8,int(np.ceil(mass.sum()/nominal)))
if k>1024:raise ValueError('Declared bounded K limit exceeded; no silent scale change')
contract=dict(type_source='Frozen previous 3-hop spectral proxy, not validated wall/rib semantics. This intervention fixes connected-region/aggregation volume scale only, not descriptor support.',minimum_region_volume_raw=float(minimum),minimum_fraction=1/512,S_nominal_raw=float(nominal),S_rule='Half of count-median connected same-type region volume AFTER fixed minimum-volume merge; node count not used',K_floor=8,K=k,S_realized_raw=float(mass.sum()/k),volume_unit='raw coordinate cubed; multiply by 1e-9 for hypothesized m^3 only',thresholds_unchanged=dict(sorted_volume_fraction_l1=.1,aspect_quantile_ratio=1.25,cross_edge_fraction_delta=.05),alphas=[1,4,16,64],control='Exact actual edge-cost multiset permutation within 20 edge-length quantile strata',repair_rule='Same pre-partition region cleanup for every arm; no per-arm volume/shape repair and no relaxed matching',decision_timing='Written before generating ANY new partitions',seed=811)
(out/'scale_contract.json').write_text(json.dumps(contract,indent=2)+'\n');contract_hash=hashlib.sha256((out/'scale_contract.json').read_bytes()).hexdigest()
print(a.case+' scale fixed '+json.dumps({key:contract[key] for key in ['K','S_nominal_raw','S_realized_raw','minimum_region_volume_raw']}),flush=True)
seeds=farthest_seeds(x,mass,k);records={};cuts={}
rng=np.random.default_rng(1729);rng.normal(size=(3,3));perm=rng.permutation(len(kind));random_kind=cleaned[perm]
cross=cleaned[edges[:,0]]!=cleaned[edges[:,1]]
def run(name,weights,use_seeds):
tick=time.monotonic();labels=connected_voronoi(graph_from_edges(len(x),edges,weights),use_seeds)
rec=partition_report(labels,graph,edges,x,mass,cleaned);rec['seconds']=time.monotonic()-tick
rec['type_boundary_cut_recall']=float((labels[edges[cross,0]]!=labels[edges[cross,1]]).mean()) if cross.any() else None
records[name]=rec;cuts[name]=labels
run('generic_S',length,seeds)
# Isolate field cleanup at old K, reusing archived generic cut/seeds.
records['generic_K32']=partition_report(saved['generic'],graph,edges,x,mass,cleaned);cuts['generic_K32']=saved['generic']
run('type_K32_alpha4',length*(1+4*cross),saved['seeds'])
run('old_control_K32_alpha4',length*(1+4*(random_kind[edges[:,0]]!=random_kind[edges[:,1]])),saved['seeds'])
run('old_control_S_alpha4',length*(1+4*(random_kind[edges[:,0]]!=random_kind[edges[:,1]])),seeds)
comparisons={}
for alpha in contract['alphas']:
weights=length*(1+alpha*cross);controlled=histogram_control(weights,length)
run(f'type_S_alpha{alpha}',weights,seeds);run(f'control_S_alpha{alpha}',controlled,seeds)
t=records[f'type_S_alpha{alpha}'];c=records[f'control_S_alpha{alpha}'];g=records['generic_S']
tg=matched_acceptance(t,g);cg=matched_acceptance(c,g);tc=matched_acceptance(t,c)
comparisons[str(alpha)]=dict(type_vs_generic=tg,control_vs_generic=cg,type_vs_control=tc,all_three_pass_partial_screen=all(r['pass_provisional'] for r in [tg,cg,tc]),type_entropy_reduction_relative=1-t['within_region_type_entropy']/g['within_region_type_entropy'] if g['within_region_type_entropy'] else None,edge_cost_histogram_exact=bool(np.array_equal(np.sort(weights),np.sort(controlled))))
ablations={name:matched_acceptance(records[name],records[ref]) for name,ref in [('type_K32_alpha4','generic_K32'),('old_control_K32_alpha4','generic_K32'),('old_control_S_alpha4','generic_S')]}
old_random=kind[perm];old_boundary=kind[edges[:,0]]!=kind[edges[:,1]];old_control_boundary=old_random[edges[:,0]]!=old_random[edges[:,1]]
result=dict(case=a.case,contract=contract,contract_sha256=contract_hash,raw_regions=before,cleaned_regions=after,cleanup=merges,old_boundary_edge_fraction=float(old_boundary.mean()),old_control_boundary_edge_fraction=float(old_control_boundary.mean()),archived_old_control_alpha4_matching=old['partitions']['control_alpha4']['matching'],records=records,comparisons=comparisons,ablations=ablations,wall_seconds=time.monotonic()-start,peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,interpretation='Partial matching diagnostic, NOT full H1 acceptance. Old tolerance function reused unchanged; boundary exposure and pool inference remain outside that function. No partitions selected using prediction labels, no training.')
np.savez_compressed(out/'partitions.npz',cleaned_type=cleaned,seeds=seeds,**cuts)
(out/'result.json').write_text(json.dumps(result,indent=2)+'\n')
print(json.dumps({'case':a.case,'raw_regions':before['regions'],'cleaned_regions':after['regions'],'K':k,'changed_volume_fraction':merges['changed_volume_fraction'],'matching_at_alphas':{a:b['all_three_pass_partial_screen'] for a,b in comparisons.items()},'wall_seconds':result['wall_seconds'],'peak_rss_kib':result['peak_rss_kib']},indent=2),flush=True)
if __name__=='__main__':main()