{ "cells": [ { "cell_type": "markdown", "id": "26027b02", "metadata": {}, "source": [ "# `het-gnn` — heterogeneous-GNN traffic assignment (act three)\n", "\n", "**What.** `het-gnn` is a lean variant of Liu & Meidani's (2024) heterogeneous-\n", "graph-neural-network traffic assignment surrogate (`[liu2024end]`,\n", "[docs/REFERENCES.md](../../docs/REFERENCES.md)): real road links and virtual\n", "OD links are two edge types over one node set, typed attention passes\n", "messages, and an edge MLP predicts each real link's flow/capacity ratio.\n", "Unlike `implicit-ue-nn`, the equilibrium is NOT architectural — flow\n", "conservation enters only as a soft training-loss penalty — so the raw emission\n", "is a per-link regression that routes no demand exactly.\n", "\n", "**Why it is in the benchmark.** It completes a **gradient of feasibility\n", "mechanisms** across the benchmark's three learned models: `learned-surrogate`\n", "has no conservation and is censored; `het-gnn` has SOFT conservation and is\n", "censored raw, but recovers feasibility by an explicit decode; `implicit-ue-nn`\n", "has conservation BY CONSTRUCTION. See\n", "[docs/design/adr-026-het-gnn.md](../../docs/design/adr-026-het-gnn.md) for the\n", "full derivation, the honest sourcing (the canon paper is paywalled and was\n", "attributed unread; the formulation was cross-verified with zero discrepancies\n", "from the authors' own preprint and NSF accepted manuscript), and every\n", "measured anchor.\n", "\n", "**Scope.** The size-agnostic node-kernel's exact permutation equivariance\n", "(A4), the raw-censored / decode-recovered two-checkpoint story (A2 — the\n", "central content of this notebook), the in-family training and conservation\n", "ablation, and the honest held-out headline on Sioux Falls." ] }, { "cell_type": "markdown", "id": "d4ca2938", "metadata": {}, "source": [ "## How this notebook is graded\n", "\n", "**A notebook never claims a number it does not compute in that cell.** Every\n", "scored quantity below — feasibility, the certified relative gap, the\n", "node-balance residual, the wmape flow errors, the permutation-equivariance\n", "diff — is recomputed live by the P1 `Evaluator` (or an explicit numeric check)\n", "from the flows the model emitted, in the cell where it is claimed. The certified-\n", "gap ordering against `implicit-ue-nn` is reported as a STABLE structural bound,\n", "never a tight inequality — the adr-026 review proved that particular ordering\n", "is not a CI invariant, and pinning it tightly would be exactly the kind of\n", "claim this benchmark exists to catch ([README](../../README.md), *Certified,\n", "not self-reported*)." ] }, { "cell_type": "code", "execution_count": 1, "id": "9d2f50f4", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:50:04.904881Z", "iopub.status.busy": "2026-07-21T13:50:04.904580Z", "iopub.status.idle": "2026-07-21T13:50:06.861995Z", "shell.execute_reply": "2026-07-21T13:50:06.860897Z" } }, "outputs": [], "source": [ "# Setup. `het-gnn` needs the optional `torch` extra (`pip install tabench[torch]`);\n", "# the guard mirrors `src/tabench/models/__init__.py`'s own import-guard pattern.\n", "#\n", "# The inline backend is Agg-based: figures render headlessly into the notebook,\n", "# so CI can execute tutorials without a display. NEVER matplotlib.use(\"Agg\")\n", "# in-kernel — it silently suppresses inline figure capture.\n", "%matplotlib inline\n", "try:\n", " import torch # noqa: F401 (the optional torch extra; absence -> ModuleNotFoundError)\n", "except ModuleNotFoundError as exc:\n", " if exc.name != \"torch\":\n", " raise\n", " raise ModuleNotFoundError(\n", " \"het-gnn needs the optional 'torch' extra: pip install tabench[torch]\"\n", " ) from exc\n", "\n", "import numpy as np\n", "\n", "from tabench import (\n", " BiconjugateFrankWolfeModel,\n", " Budget,\n", " Evaluator,\n", " LearnedSurrogateModel,\n", " RngBundle,\n", " Trace,\n", " braess_scenario,\n", " load_scenario,\n", " viz,\n", ")\n", "from tabench.core.scenario import Demand, Network, Scenario\n", "from tabench.metrics.gaps import node_balance_residual\n", "from tabench.models import het_gnn as M\n", "from tabench.models._paths import PathEngine\n", "from tabench.models.het_gnn import HetGNNModel\n", "from tabench.models.implicit_ue import ImplicitUENNModel\n", "from tabench.models.learned import _random_network_scenario" ] }, { "cell_type": "markdown", "id": "f719dcd9", "metadata": {}, "source": [ "## A gradient of feasibility mechanisms, and a decisive coincidence\n", "\n", "| model | conservation | raw emission | feasible score |\n", "|---|---|---|---|\n", "| `learned-surrogate` | none | censored | never |\n", "| **`het-gnn`** | **soft loss** (`w_c=0.05`) | **censored** | **by an explicit decode** |\n", "| `implicit-ue-nn` | architectural | feasible | by construction |\n", "\n", "The paper's own conservation metric `L~_c` **is** the L1/D form of the\n", "harness's censoring statistic `node_balance_residual` — the paper trains\n", "toward exactly the quantity the audit thresholds. Its own best reported\n", "values still land 3–5 orders of magnitude above the `1e-6*D` feasibility\n", "tolerance, so the paper-faithful raw emission is censored with certainty,\n", "trained or untrained. That censored row is the honest headline; the decode\n", "(a REPO EXTENSION, not in the paper) is what puts a certified gap on the\n", "leaderboard." ] }, { "cell_type": "code", "execution_count": 2, "id": "02effb36", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:50:06.866002Z", "iopub.status.busy": "2026-07-21T13:50:06.865743Z", "iopub.status.idle": "2026-07-21T13:50:06.869953Z", "shell.execute_reply": "2026-07-21T13:50:06.869386Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "scenario : braess\n", "content hash : cf00f411cdccec88…\n", "total demand : 6.0\n" ] } ], "source": [ "scenario = braess_scenario()\n", "print(f\"scenario : {scenario.name}\")\n", "print(f\"content hash : {scenario.content_hash()[:16]}…\")\n", "print(f\"total demand : {scenario.demand.total}\")" ] }, { "cell_type": "markdown", "id": "5a08a224", "metadata": {}, "source": [ "## A4 — the size-agnostic node-kernel is EXACTLY permutation equivariant\n", "\n", "The paper's node feature is that node's entire OD-demand row plus two\n", "geographic coordinates — machine-verified to change by 21.5 under a\n", "consistent node relabeling (NOT permutation equivariant), and its dimension\n", "is `|V|`, forcing transfer learning or dummy-node padding to change graph\n", "size. The lean substitution here is the intrinsic per-node\n", "`[production, attraction, out_degree, in_degree]`: exactly equivariant, so\n", "ONE trained model runs on every graph size — link-kernel in `implicit-ue-nn`,\n", "node-kernel here, both size-agnostic by different routes. We also check the\n", "mirror of `implicit-ue-nn`'s A4: at RANDOM untrained weights, the DECODE is\n", "demand-feasible by construction (the raw regression is not)." ] }, { "cell_type": "code", "execution_count": 3, "id": "74bde6f8", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:50:06.872023Z", "iopub.status.busy": "2026-07-21T13:50:06.871840Z", "iopub.status.idle": "2026-07-21T13:50:07.006612Z", "shell.execute_reply": "2026-07-21T13:50:07.005987Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "max |raw ratio(base) - raw ratio(permuted)| : 2.78e-16 (paper's featurization: 21.5)\n", "decoded (random weights) node_balance_residual : 8.88e-16\n" ] } ], "source": [ "def _permute_scenario(base: Scenario, perm: np.ndarray) -> Scenario:\n", " # Relabel node u -> perm[u] (0-based), edge ORDER fixed: edge a is the same\n", " # road segment with relabeled endpoints in both scenarios.\n", " net = base.network\n", " nz = net.n_zones\n", " od = base.demand.matrix\n", " od_p = np.zeros_like(od)\n", " for i in range(nz):\n", " for j in range(nz):\n", " od_p[perm[i], perm[j]] = od[i, j]\n", " net_p = Network(\n", " name=\"perm\", n_nodes=net.n_nodes, n_zones=nz, first_thru_node=net.first_thru_node,\n", " init_node=perm[net.init_node - 1] + 1, term_node=perm[net.term_node - 1] + 1,\n", " capacity=net.capacity, length=net.length, free_flow_time=net.free_flow_time,\n", " b=net.b, power=net.power, toll=net.toll, link_type=net.link_type,\n", " )\n", " return Scenario(name=\"perm\", network=net_p, demand=Demand(od_p), family=\"fuzz-perm\")\n", "\n", "\n", "base = _random_network_scenario(2, 10, 4, 6)\n", "n, nz = base.network.n_nodes, base.network.n_zones\n", "rng = np.random.default_rng(0)\n", "perm = np.arange(n)\n", "perm[:nz] = rng.permutation(nz)\n", "perm[nz:] = nz + rng.permutation(n - nz)\n", "sc_perm = _permute_scenario(base, perm)\n", "\n", "torch.manual_seed(7)\n", "untrained_gnn = M._HetGNN() # equivariance is architectural, holds at any fixed weights\n", "with torch.no_grad():\n", " a = untrained_gnn(M._het_graph(base.network, base.demand))\n", " a_p = untrained_gnn(M._het_graph(sc_perm.network, sc_perm.demand))\n", "max_diff = float((a - a_p).abs().max())\n", "print(f\"max |raw ratio(base) - raw ratio(permuted)| : {max_diff:.2e} (paper's featurization: 21.5)\")\n", "assert max_diff < 1e-8\n", "\n", "# The decode mirror of implicit-ue-nn's A4: random untrained weights, feasible decode.\n", "engine = PathEngine(scenario.network)\n", "rs = M._build_routes(scenario.network, scenario.demand, engine, M._N_CG)\n", "with torch.no_grad():\n", " v_raw_untrained = torch.clamp(untrained_gnn(M._het_graph(scenario.network, scenario.demand)), min=0.0)\n", " v_raw_untrained = v_raw_untrained * M._het_graph(scenario.network, scenario.demand)[\"cap\"]\n", "h_untrained, _, _ = M._decode(rs, v_raw_untrained, M._N_DECODE)\n", "v_dec_untrained = (rs.delta.t() @ h_untrained).numpy()\n", "print(f\"decoded (random weights) node_balance_residual : {node_balance_residual(scenario, v_dec_untrained):.2e}\")\n", "assert node_balance_residual(scenario, v_dec_untrained) < 1e-9\n", "assert Evaluator(scenario).evaluate(v_dec_untrained)[\"feasible\"] == 1.0" ] }, { "cell_type": "markdown", "id": "ac25bb12", "metadata": {}, "source": [ "## A2 — the two-checkpoint story: raw censored, decode recovered\n", "\n", "`solve` records TWO harness-certified checkpoints from ONE call, both\n", "recomputed by the same P1 `Evaluator` — nothing self-attested. On Sioux Falls\n", "(a disjoint TNTP scenario, a different topology AND congestion regime than\n", "the 8–14-node synthetic training family): the RAW emission needs no shortest\n", "path (`sp_calls=0`, a genuinely new budget point below the ridge's 1) and is\n", "censored; the DECODE runs `n_cg` column-generation sweeps and earns a real\n", "certified gap." ] }, { "cell_type": "code", "execution_count": 4, "id": "09a1ffab", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:50:07.008637Z", "iopub.status.busy": "2026-07-21T13:50:07.008333Z", "iopub.status.idle": "2026-07-21T13:50:18.908746Z", "shell.execute_reply": "2026-07-21T13:50:18.907325Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "raw : sp_calls=0 iterations=0 feasible=0 node_balance_residual=295.9\n", "decode : sp_calls=6 feasible=1 relative_gap=0.2586\n" ] } ], "source": [ "sc = load_scenario(\"siouxfalls\")\n", "assert sc.family != M.TRAINING_FAMILY # disjoint from the training family, by hash\n", "\n", "trace = Trace()\n", "HetGNNModel().solve(sc, Budget(iterations=M._N_DECODE), RngBundle(0), trace)\n", "assert len(trace) == 2\n", "raw, dec = trace.checkpoints[0], trace.checkpoints[1]\n", "\n", "m_raw = Evaluator(sc).evaluate(raw.link_flows)\n", "print(f\"raw : sp_calls={raw.coords.sp_calls} iterations={raw.coords.iterations} \"\n", " f\"feasible={m_raw['feasible']:.0f} node_balance_residual={node_balance_residual(sc, raw.link_flows):.1f}\")\n", "assert raw.coords.sp_calls == 0 and raw.coords.iterations == 0\n", "assert m_raw[\"feasible\"] == 0.0\n", "assert node_balance_residual(sc, raw.link_flows) > 1e-6 * sc.demand.total\n", "\n", "m_dec = Evaluator(sc).evaluate(dec.link_flows)\n", "print(f\"decode : sp_calls={dec.coords.sp_calls} feasible={m_dec['feasible']:.0f} \"\n", " f\"relative_gap={m_dec['relative_gap']:.4f}\")\n", "assert dec.coords.sp_calls == M._N_CG\n", "assert m_dec[\"feasible\"] == 1.0\n", "assert np.isfinite(m_dec[\"relative_gap\"]) and 0.0 < m_dec[\"relative_gap\"] < 1.0\n", "assert dec.self_report[\"training_sp_calls\"] > 0\n", "assert \"decode_residual\" in dec.self_report" ] }, { "cell_type": "markdown", "id": "07191230", "metadata": {}, "source": [ "## In-family training, and the conservation ablation\n", "\n", "Two in-sample checks, scoped honestly to the training family (never claimed\n", "to transfer): Adam genuinely reduces the composite flow loss below an\n", "untrained head's, and training WITH the soft conservation loss (`w_c=0.05`)\n", "yields a lower in-family aggregate node-balance residual than training\n", "WITHOUT it (`w_c=0`) — the paper's contribution made measurable. This ablation\n", "does NOT transfer to the held-out net (adr-026, measured backwards on Sioux\n", "Falls) — the identifiability caveat again, pinned honestly rather than forced." ] }, { "cell_type": "code", "execution_count": 5, "id": "8a49d62e", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:50:18.912719Z", "iopub.status.busy": "2026-07-21T13:50:18.911968Z", "iopub.status.idle": "2026-07-21T13:55:12.610606Z", "shell.execute_reply": "2026-07-21T13:55:12.609385Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "family loss trained=282.1 untrained=652.5\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "in-family node-balance residual w_c=0.05: 6.4 w_c=0: 11.7\n" ] } ], "source": [ "cases = M._training_cases()\n", "\n", "\n", "def _family_loss(model) -> float:\n", " total = 0.0\n", " with torch.no_grad():\n", " for c in cases:\n", " total += float(((model(c[\"g\"]) * c[\"cap\"] - c[\"v_obs\"]) ** 2).sum()) / c[\"scale\"]\n", " return total\n", "\n", "\n", "def _in_family_cons_residual(model) -> float:\n", " total = 0.0\n", " with torch.no_grad():\n", " for c in cases:\n", " f = model(c[\"g\"]) * c[\"cap\"]\n", " total += float(M._conservation_residual(f, c[\"g\"], c[\"expected\"])) / c[\"scale\"]\n", " return total\n", "\n", "\n", "trained, _ = M._train() # cached; the default w_c=0.05 head\n", "torch.manual_seed(M._TRAIN_SEED)\n", "untrained = M._HetGNN()\n", "print(f\"family loss trained={_family_loss(trained):.1f} untrained={_family_loss(untrained):.1f}\")\n", "assert _family_loss(trained) < _family_loss(untrained)\n", "\n", "head_wc = M._fit(cases, w_cons=M._W_CONS)\n", "head_0 = M._fit(cases, w_cons=0.0)\n", "res_wc, res_0 = _in_family_cons_residual(head_wc), _in_family_cons_residual(head_0)\n", "print(f\"in-family node-balance residual w_c={M._W_CONS}: {res_wc:.1f} w_c=0: {res_0:.1f}\")\n", "assert res_wc < res_0" ] }, { "cell_type": "markdown", "id": "c6ffd02e", "metadata": {}, "source": [ "## The honest held-out headline\n", "\n", "Every axis NAMED and MEASURED, never a pre-committed flattering direction:\n", "the raw emission's flow error is WORSE than the ridge surrogate's (censored\n", "either way); the decode's is BETTER (projecting onto the feasible polytope\n", "recovers accuracy); `implicit-ue-nn` and `het-gnn` are both feasible with\n", "gaps in a sane band at matched route sets (the adr-026 review proved the\n", "tight ordering between them is NOT a CI invariant — reported as a stable\n", "structural bound only); and a converged `bfw` wins the wall/convergence axis\n", "by orders, as always." ] }, { "cell_type": "code", "execution_count": 6, "id": "2db31633", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:55:12.613795Z", "iopub.status.busy": "2026-07-21T13:55:12.613375Z", "iopub.status.idle": "2026-07-21T13:55:24.559940Z", "shell.execute_reply": "2026-07-21T13:55:24.558658Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "wmape raw=0.5603 decoded=0.1676 ridge=0.2820\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "certified gap implicit-ue-nn=0.1684 het-gnn(decoded)=0.2586 (STABLE structural bound only — not a tight ordering, adr-026)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "bfw (converged) : relative_gap=3.228e-06 (the wall/convergence axis)\n" ] } ], "source": [ "oracle = sc.reference.link_flows\n", "wmape = lambda v: float(np.abs(v - oracle).sum() / np.abs(oracle).sum())\n", "\n", "v_ridge = LearnedSurrogateModel().solve(sc, Budget(iterations=1), RngBundle(0), Trace()).final.link_flows\n", "m_ridge = Evaluator(sc).evaluate(v_ridge)\n", "assert m_ridge[\"feasible\"] == 0.0 # a per-link regressor routes nobody either\n", "\n", "print(f\"wmape raw={wmape(raw.link_flows):.4f} decoded={wmape(dec.link_flows):.4f} \"\n", " f\"ridge={wmape(v_ridge):.4f}\")\n", "assert wmape(raw.link_flows) > wmape(v_ridge) # raw transfers WORSE than the ridge\n", "assert wmape(dec.link_flows) < wmape(v_ridge) # decoded transfers BETTER\n", "\n", "v_impl = ImplicitUENNModel().solve(sc, Budget(iterations=3000), RngBundle(0), Trace()).final.link_flows\n", "m_impl = Evaluator(sc).evaluate(v_impl)\n", "print(f\"certified gap implicit-ue-nn={m_impl['relative_gap']:.4f} het-gnn(decoded)={m_dec['relative_gap']:.4f}\"\n", " \" (STABLE structural bound only — not a tight ordering, adr-026)\")\n", "assert m_impl[\"feasible\"] == 1.0\n", "assert 0.02 < m_impl[\"relative_gap\"] < 0.6\n", "assert 0.02 < m_dec[\"relative_gap\"] < 0.6\n", "\n", "v_bfw = BiconjugateFrankWolfeModel().solve(\n", " sc, Budget(iterations=300, target_relative_gap=1e-6), RngBundle(0), Trace()\n", ").final.link_flows\n", "m_bfw = Evaluator(sc).evaluate(v_bfw)\n", "print(f\"bfw (converged) : relative_gap={m_bfw['relative_gap']:.3e} (the wall/convergence axis)\")\n", "assert m_bfw[\"relative_gap\"] < 1e-4 < m_dec[\"relative_gap\"]" ] }, { "cell_type": "markdown", "id": "f12a01d6", "metadata": {}, "source": [ "## Visualize\n", "\n", "The certified artifact (the decoded checkpoint) is per-link flows on a road\n", "`Network`, the same shape every static model here emits, so `tabench.viz`\n", "applies directly (adr-035's viz rule)." ] }, { "cell_type": "code", "execution_count": 7, "id": "f575e971", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:55:24.564619Z", "iopub.status.busy": "2026-07-21T13:55:24.564407Z", "iopub.status.idle": "2026-07-21T13:55:25.283501Z", "shell.execute_reply": "2026-07-21T13:55:25.282689Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display(viz.plot_network_flows(sc.network, dec.link_flows))\n", "display(viz.plot_flow_scatter((\"bfw (converged)\", v_bfw), {\"het-gnn (decoded)\": dec.link_flows}))" ] }, { "cell_type": "markdown", "id": "9dfafc73", "metadata": {}, "source": [ "## Takeaways & pointers\n", "\n", "- **A decisive coincidence, not a bug in the paper.** Its own conservation\n", " metric IS the harness's censoring statistic, orders above tolerance even at\n", " its best reported values — the raw emission is censored with certainty,\n", " which is why the decode (a REPO EXTENSION) exists at all.\n", "- **Two checkpoints, nothing self-attested.** The runner certifies both from\n", " the emitted flows; the paper-faithful censored row stays visible in the\n", " same trace as the certified decode.\n", "- **Size-agnostic by a different route than `implicit-ue-nn`.** Link-kernel\n", " there, node-kernel here — both exactly equivariant, both transfer across\n", " graph sizes with no retraining.\n", "- **The certified-gap ordering against `implicit-ue-nn` is provenance, not a\n", " claim.** It flips under retraining and weight perturbation (adr-026); this\n", " notebook asserts only the stable structure.\n", "- **Where next.** `implicit-ue-nn`\n", " ([01-implicit-ue-nn.ipynb](01-implicit-ue-nn.ipynb)) for the architectural\n", " (not decoded) feasibility mechanism; the full derivation and every measured\n", " anchor in [docs/design/adr-026-het-gnn.md](../../docs/design/adr-026-het-gnn.md)." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.12" }, "tabench": { "covers": [], "requires_extra": "torch", "track": "learned", "unit": "het-gnn" } }, "nbformat": 4, "nbformat_minor": 5 }