#!/usr/bin/env python3 """Diagnostic B (homemaker-py-erc.2, DESIGN.md §13.2): undersize-despite-slack localization — construction-target vs inner-loop-fill. GATES the plot-fill-construction (`erc.4`) vs inner-loop-slack-expansion (`erc.6`) decision. The paradox from §12.3: plot utilisation is ~0.44 (over half the plot empty) yet size fails are large (rooms UNDERSIZE). Where is the slack stranded, and at which stage should it be spent? Reads, does not change behaviour. For each programme x seed it builds the §12.2 constructive seed (adjacency- and proportion-aware) — whose geometry already sits at the proportion-aware TARGET ratios (`_size_divisions_from_targets`, the inner loop's warm-start), so this IS the "before inner loop" state — then runs `innerloop.optimise` to get the "after inner loop" state, and measures at each: 1. Per sized-room leaf: achieved area vs target area (get_space_params size), classified undersize / at-target / oversize, plus authoritative size-fail count from `score_with_fails`. 2. Plot accounting: total plot area split into sized-room / circulation / outside, and the room-target sum vs plot (could rooms even fill the plot?). 3. Whether the INNER LOOP moves any of it: size fails before vs after, util before vs after, oversize leaves before vs after. DECISION RULE: if rooms are parked at/under target with the slack sitting as unused plot (rooms can't fill it / no oversize to rebalance) -> fix in CONSTRUCTION (plot-fill, `erc.4`). If the inner loop has room to expand (oversize coexists with undersize, slack is inside the sized leaves) but does not spend it -> no objective gradient -> fix in the INNER LOOP (slack-expansion term, `erc.6`). Usage: URB_NO_OCCLUSION=1 python3 experiments/diag_slack_localization.py """ from __future__ import annotations import copy import sys from pathlib import Path import numpy as np sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src")) from homemaker_layout import ( # noqa: E402 dom, fitness, geometry, innerloop, operators, programme, ) PROGRAMMES = ["harbor-house", "maple-court"] SEEDS = (0, 1, 2) BUDGET = 80 # constructed bootstrap seeds get child_budget (driver default 80) AT_TARGET_TOL = 0.10 # |achieved/target - 1| <= tol counts as "at target" ROOT = Path(__file__).resolve().parents[1] def _is_sized(leaf, reqs) -> bool: return leaf.type in reqs and reqs[leaf.type].size > 0 def _t0(leaf) -> str: return leaf.type[0].lower() if leaf.type else "" def _measure(tree, fit, reqs): """Per-leaf achieved-vs-target + plot accounting for one laid-out tree.""" geometry.clear_cache() _score, fails = fit.score_with_fails(copy.deepcopy(tree)) size_fails = sum(1 for f in fails if f.endswith(" size")) leaves = [lf for lvl in dom.levels(tree) for lf in lvl.leaves()] geometry.clear_cache() plot = sum(geometry.area(lvl) for lvl in dom.levels(tree)) sized_area = circ_area = out_area = 0.0 target_sum = 0.0 under = at = over = 0 ratios = [] for lf in leaves: a = geometry.area(lf) t0 = _t0(lf) if _is_sized(lf, reqs): target = fit.get_space_params(lf.type, "size")[0] sized_area += a target_sum += target r = a / target if target else float("nan") ratios.append(r) if r < 1.0 - AT_TARGET_TOL: under += 1 elif r > 1.0 + AT_TARGET_TOL: over += 1 else: at += 1 elif t0 == "c": circ_area += a else: out_area += a n_sized = len(ratios) return { "size_fails": size_fails, "plot": plot, "sized_area": sized_area, "circ_area": circ_area, "out_area": out_area, "target_sum": target_sum, "n_sized": n_sized, "util": sized_area / plot if plot else float("nan"), "target_fill": target_sum / plot if plot else float("nan"), "mean_ratio": float(np.mean(ratios)) if ratios else float("nan"), "under": under, "at": at, "over": over, "pct_under": 100.0 * under / n_sized if n_sized else float("nan"), "pct_over": 100.0 * over / n_sized if n_sized else float("nan"), } def _leaf_ratios(tree, fit, reqs): """(a/t, type, target, achieved) for every sized-room leaf.""" geometry.clear_cache() out = [] for lvl in dom.levels(tree): for lf in lvl.leaves(): if _is_sized(lf, reqs): t = fit.get_space_params(lf.type, "size")[0] a = geometry.area(lf) out.append((a / t if t else float("nan"), lf.type, t, a)) return out def _run_seed(pdir, fit, reqs, types, seed_root, s): rng = np.random.default_rng(s) topo = operators.constructive_topology( seed_root, reqs, rng, types, adjacency_aware=True, proportion_aware=True, circ_divisor=3) before = _measure(topo, fit, reqs) after_tree = copy.deepcopy(topo) r = innerloop.optimise(after_tree, str(pdir), x0=None, budget=BUDGET, method="nm", use_native=True) after = _measure(after_tree, fit, reqs) after["n_evals"] = r.n_evals return before, after, _leaf_ratios(topo, fit, reqs) def _avg(rows, key): vals = [r[key] for r in rows if not (isinstance(r[key], float) and r[key] != r[key])] return sum(vals) / len(vals) if vals else float("nan") def main() -> int: print("Diagnostic B — undersize-despite-slack localization (§13.2)\n") print("BEFORE = constructive seed at proportion-aware TARGET ratios " "(inner-loop warm start)") print(f"AFTER = after innerloop.optimise (nm, budget={BUDGET})") print(f"Seeds: {SEEDS} at-target tol: +/-{AT_TARGET_TOL:.0%}\n") for name in PROGRAMMES: pdir = ROOT / "examples" / name reqs = programme.load_programme_dir(pdir) types = sorted(reqs) + ["C", "O"] conf, cost = fitness.load_config(pdir) fit = fitness.Fitness(conf, cost) seed_root = dom.load(str(pdir / "init.dom")) befores, afters = [], [] detail0 = None for s in SEEDS: b, a, leaf_rows = _run_seed(pdir, fit, reqs, types, seed_root, s) befores.append(b) afters.append(a) if detail0 is None: detail0 = leaf_rows n_sized = _avg(befores, "n_sized") print(f"=== {name} (sized rooms/seed: {n_sized:.0f}) ===") print(f"{'':16}{'sizeF':>7}{'util':>7}{'tgtFill':>8}{'a/t':>6}" f"{'%und':>6}{'%ovr':>6}{'sized%':>7}{'circ%':>7}{'out%':>7}") for label, rows in (("BEFORE (target)", befores), ("AFTER (innerloop)", afters)): plot = _avg(rows, "plot") print(f"{label:16}" f"{_avg(rows,'size_fails'):>7.1f}" f"{_avg(rows,'util'):>7.2f}" f"{_avg(rows,'target_fill'):>8.2f}" f"{_avg(rows,'mean_ratio'):>6.2f}" f"{_avg(rows,'pct_under'):>6.0f}" f"{_avg(rows,'pct_over'):>6.0f}" f"{100*_avg(rows,'sized_area')/plot:>7.0f}" f"{100*_avg(rows,'circ_area')/plot:>7.0f}" f"{100*_avg(rows,'out_area')/plot:>7.0f}") print(f" plot area ~ {_avg(befores,'plot'):.0f} m2; " f"room-target sum ~ {_avg(befores,'target_sum'):.0f} m2 " f"(tgtFill = target sum / plot)") print(f" inner-loop evals/seed ~ {_avg(afters,'n_evals'):.0f}") # Same-target maldistribution evidence (seed 0): a leaf's area is set by # its SLICING POSITION, not its target. The same room TYPE/target lands # at both extremes -> depth-driven, not unclaimed plot, not tiny-target. detail0.sort(reverse=True) print(" seed-0 extremes (type / target / achieved / a-over-t):") for r, ty, t, a in detail0[:3]: print(f" OVER {ty:5} t={t:5.1f} a={a:6.1f} a/t={r:5.2f}") for r, ty, t, a in detail0[-3:]: print(f" UNDER {ty:5} t={t:5.1f} a={a:6.1f} a/t={r:5.2f}") print() print("READ: util = sized-room area / plot. tgtFill = sum of room targets / plot:") print(" if tgtFill << 1, rooms cannot fill the plot even at target -> slack is") print(" structurally unassigned (CONSTRUCTION / erc.4). %ovr>0 alongside %und") print(" with AFTER unchanged -> slack is inside leaves but inner loop won't spend") print(" it (no gradient -> INNER LOOP / erc.6).") return 0 if __name__ == "__main__": sys.exit(main())