Files
MeltMind/tools/diagnose_850_shape.py
T

116 lines
7.8 KiB
Python

"""Read-only diagnosis of saved constrained cuts; no new partition or tolerance."""
import argparse
import csv
import hashlib
import json
from pathlib import Path
import numpy as np
from review_partition_scale import regions, histogram_control
def main():
parser = argparse.ArgumentParser()
parser.add_argument('output', type=Path)
out = parser.parse_args().output
target = out / 'shape_850_diagnosis.json'
if target.exists():
raise FileExistsError(target)
directory = next(Path('artifacts/capacity-projectors-2026-11-13').glob('00000850*'))
case = directory.name
old = Path('artifacts/routes-review-2026-11-13') / case
result = json.loads((directory / 'capacity_result.json').read_text())
prior = json.loads((old / 'result.json').read_text())
config = json.loads((old / 'scale_contract.json').read_text())
assert hashlib.sha256((old / 'scale_contract.json').read_bytes()).hexdigest() == result['contract']['source_scale_contract_sha256']
cache = np.load(old / 'partitions.npz')
cuts = np.load(directory / 'candidate_partitions.npz')
data = np.load(Path('artifacts/intake-2026-11-13/samples') / (case + '.npz'))
x, mass, edges = data['points_raw'], data['node_volume_raw'], data['edges']
kind, seeds = cache['cleaned_type'], cache['seeds']
region, rv, rt = regions(kind, edges, mass)
length = np.linalg.norm(x[edges[:, 0]] - x[edges[:, 1]], axis=1)
cross_type = kind[edges[:, 0]] != kind[edges[:, 1]]
S = config['S_realized_raw']
regional = []
for r in range(len(rv)):
ids = np.flatnonzero(region == r)
regional.append(dict(region=r, type=int(rt[r]), volume=float(rv[r]), volume_over_S=float(rv[r]/S),
below_capacity_lower=bool(rv[r] < .95*S), seeds=int(np.sum(region[seeds] == r)),
bounding_box=[x[ids].min(0).tolist(), x[ids].max(0).tolist()],
occupied_groups_by_arm={name: len(np.unique(cuts[name][ids])) for name in cuts.files}))
arms = {}
all_groups = []
for name in cuts.files:
labels = cuts[name]
weights = length if name == 'generic' else length*(1+int(name.split('_')[1])*cross_type)
if name.startswith('control'):
weights = histogram_control(weights, length)
digest = hashlib.sha256(weights.tobytes()).hexdigest()
assert digest == result['records'][name]['cost_hash_before'] == result['records'][name]['cost_hash_after']
previous_name = 'generic_S' if name == 'generic' else name.split('_')[0]+'_S_alpha'+name.split('_')[1]
previous_labels = cache[previous_name]
groups = []
for g in range(len(seeds)):
ids = np.flatnonzero(labels == g)
center = np.average(x[ids], axis=0, weights=mass[ids])
delta = x[ids] - center
covariance = (delta * mass[ids, None]).T @ delta / mass[ids].sum()
eig = np.linalg.eigvalsh(covariance)
assert eig[0] > 1e-24
aspect = float(np.sqrt(eig[-1]/eig[0]))
assert np.isclose(aspect, result['records'][name]['aspect'][g])
hist = np.bincount(kind[ids], weights=mass[ids], minlength=4)
rvol = np.bincount(region[ids], weights=mass[ids], minlength=len(rv))
row = dict(arm=name, group=g, seed_node=int(seeds[g]), seed_region=int(region[seeds[g]]),
seed_in_own_group=bool(labels[seeds[g]] == g), nodes=len(ids), volume_over_S=float(mass[ids].sum()/S),
center=center.tolist(), covariance_eigenvalues=eig.tolist(), aspect=aspect,
effective_mass_nodes=float(mass[ids].sum()**2/np.square(mass[ids]).sum()),
dominant_type=int(hist.argmax()), dominant_type_share=float(hist.max()/hist.sum()),
dominant_region=int(rvol.argmax()), dominant_region_share=float(rvol.max()/rvol.sum()),
regions_touched=int(np.sum(rvol > 0)), type_volume_fractions=(hist/hist.sum()).tolist(),
bounding_box=[x[ids].min(0).tolist(), x[ids].max(0).tolist()],
capacity_adjustment_symmetric_difference_mass_over_S=float(mass[(labels == g) != (previous_labels == g)].sum()/S))
groups.append(row)
all_groups.append(row)
aspect = np.array([g['aspect'] for g in groups])
pre_aspect = np.array(prior['records'][previous_name]['aspect'])
order = np.argsort(aspect)
contributors = {}
for quantile in [.1, .5, .9]:
position = (len(order)-1)*quantile
lo, hi = int(np.floor(position)), int(np.ceil(position))
contributors[str(quantile)] = dict(groups=[int(order[lo]), int(order[hi])], upper_interpolation_weight=position-lo)
generic = cuts['generic']
cut = labels[edges[:, 0]] != labels[edges[:, 1]]
arms[name] = dict(cost_hash_verified=True, aspect_quantiles=np.quantile(aspect, [.1, .5, .9]).tolist(),
pre_capacity_aspect_quantiles=np.quantile(pre_aspect, [.1, .5, .9]).tolist(),
log_quantile_change_due_to_capacity=(np.log(np.quantile(aspect, [.1, .5, .9])/np.quantile(pre_aspect, [.1, .5, .9]))).tolist(),
q90_interpolation=contributors['0.9'], top_six_aspect_groups=[groups[i] for i in order[-6:][::-1]],
all_groups=groups, capacity_changed_mass_fraction=float(mass[labels != previous_labels].sum()/mass.sum()),
different_from_generic_mass_fraction=float(mass[labels != generic].sum()/mass.sum()),
type_boundary_cut_fraction=float(cut[cross_type].mean()),
non_type_boundary_cut_fraction=float(cut[~cross_type].mean()),
mean_group_dominant_type_share=float(np.mean([r['dominant_type_share'] for r in groups])))
comparisons = {}
for alpha in [4, 16, 64]:
comparisons[str(alpha)] = {}
for lhs, rhs in [(f'type_{alpha}', 'generic'), (f'control_{alpha}', 'generic'), (f'type_{alpha}', f'control_{alpha}')]:
log = np.log(np.array(arms[lhs]['aspect_quantiles'])/arms[rhs]['aspect_quantiles'])
comparisons[str(alpha)][lhs+'__'+rhs] = dict(log_ratio_q10_q50_q90=log.tolist(),
failing_quantiles=[q for q, value in zip([.1, .5, .9], log) if abs(value) > np.log(1.25)])
target.write_text(json.dumps(dict(case=case, scope='Saved partitions only; no new cuts, remapping, or relaxed tolerances.',
scale_contract=config, type_region_table=regional, arms=arms, comparisons=comparisons,
capacity_bounds=[.95*S, 1.05*S], numerical_covariance_floor_active=False,
causal_limit='These controlled saved arms isolate cost arrangement conditional on fixed seeds and scale. They do not independently identify a better seed rule or a globally feasible shape-constrained partition.',
full_acceptance_missing=result['contract']['full_acceptance_missing']), indent=2, allow_nan=False)+'\n')
columns=['arm','group','seed_region','nodes','volume_over_S','aspect','effective_mass_nodes','dominant_type','dominant_type_share','dominant_region','dominant_region_share','regions_touched','capacity_adjustment_symmetric_difference_mass_over_S']
with (out/'shape_850_groups.csv').open('w') as stream:
writer=csv.DictWriter(stream,fieldnames=columns,extrasaction='ignore')
writer.writeheader()
writer.writerows(all_groups)
print(json.dumps({'regions':len(regional),'below_capacity_lower':sum(r['below_capacity_lower'] for r in regional),'groups_checked':len(all_groups),'comparisons':comparisons},indent=2))
if __name__ == '__main__':
main()