116 lines
7.8 KiB
Python
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()
|