Technical Summary: A Graph-Based Control Interface for Traffic Signals on Heterogeneous Road Networks

Problem Statement

Traffic signal control faces a fundamental challenge in generalization: action spaces are inherently local and heterogeneous. A three-arm junction, a standard four-arm intersection, and a complex junction with protected turns possess different numbers of phases and distinct semantic meanings for those phases. Consequently, fixed-output neural network heads (e.g., "Phase 2") lack reusable semantics across different road networks. Standard approaches that pad action spaces to a uniform size alter tensor dimensions without establishing shared meaning, while existing learned methods often struggle to decouple the scoring of traffic movements from the construction of junction-specific action spaces.

Methodology

The paper proposes a control interface that strictly separates the learned scoring of traffic movements from the deterministic construction of local action spaces.

1. Control Objects and Representation

• Movements: Defined as legal, controlled paths from an incoming road corridor to an outgoing corridor (including straight travel and turns).
• LaneGroups: Consecutive directed road segments are grouped into LaneGroups when unsignalized continuation is unambiguous. Opposite directions remain separate due to differing queue and speed dynamics.
• Phases: A phase is a compatible set of movements that may receive a green signal simultaneously. The controller selects one phase per junction rather than controlling individual lamps.

2. Graph Neural Network (GNN) Architecture

The system employs a shared, typed Graph Neural Network that operates on a city-level graph containing LaneGroup and Movement nodes.

• Message Passing: The architecture uses typed message passing with four directed relations: $L_{in} \to M$, $L_{out} \to M$, $M \to L_{in}$, and $M \to L_{out}$.
• Aggregation: It utilizes typed mean aggregation (rather than attention) to produce embeddings.
• Scoring: After two message-passing blocks, a Multi-Layer Perceptron (MLP) maps the final movement embedding ($h^{(2)}_m$) to a single scalar score ($s_m$).
• Parameter Sharing: The parameter shapes depend only on feature and hidden dimensions, making them independent of the graph size or the number of actions.

3. Deterministic Action Space Construction

The interface enforces a "narrow boundary" where learning stops at movement scoring, and deterministic code handles the rest:

• Incidence Matrix ($A_j$): For each junction $j$, a pre-computed, deterministic incidence matrix maps movement scores to phase logits. The matrix $A_j \in \{0, 1\}^{|P_j| \times |M_j|}$ indicates which movements are enabled by which phases.
• Phase Logits: The logit for a phase $p$ is calculated as the sum of the scores of its enabled movements: $\ell_{j,p} = \sum_{m \in M_j} A_{j,p,m} s_m$.
• Offline Construction: Phases are generated offline using Bron–Kerbosch enumeration to find maximal compatible movement sets based on SUMO conflict data.
• Online Execution: At runtime, an availability mask enforces minimum green times, and a categorical sample selects a phase based on the logits.

4. Training Protocol

• Algorithm: Proximal Policy Optimization (PPO) is used to optimize the complete policy.
• Reward Function: A local, dimensionless reward is assigned per junction, combining terms for progress (speed-normalized density), discharge (vehicles leaving), braking (deceleration), and gridlock (speed deficit).
• Execution: The policy operates on variable-size state graphs. For batching, junctions with matching local dimensions are grouped, avoiding padding to a universal graph size.

Key Contributions

1. Structural Decoupling: The primary contribution is the architectural interface that separates a reusable, shared GNN for movement scoring from the deterministic, junction-specific construction of action spaces. This allows the system to handle variable graph sizes and variable action counts without retraining or altering network topology.
2. Feasibility Evaluation: The paper provides empirical evidence of this interface's ability to execute across heterogeneous road networks, including unseen synthetic grid geometries and five distinct city graphs (Karlsruhe, Mannheim, Stuttgart, Heidelberg, Freiburg).
3. Transparent Boundary: Unlike prior work (e.g., TransferLight) that learns complex hierarchies or phase semantics, this approach maintains a transparent boundary where phase membership and timing remain deterministic, and the learned actor only outputs a scalar per movement.

Experimental Results

The evaluation addresses three research questions (RQs):

• RQ1 (Transfer within Synthetic Family): On unseen grid sizes (e.g., $6 \times 6$) and aspect ratios generated by the same synthetic generator, the sampled learned policy outperformed the Max-Pressure baseline in both throughput and completion rates across all demand levels (0.6, 0.7, 0.8).
• RQ2 (Distribution Shift): When signal coverage was reduced (50% and 25%), the policy trained on full coverage showed significant performance deterioration compared to Max-Pressure. This indicates sensitivity to distribution shifts in signal coverage, despite the architecture remaining structurally executable.
• RQ3 (City Feasibility): A single trained policy instance was executed across five heterogeneous city graphs. Results were mixed:
  • Karlsruhe & Stuttgart: The learned policy outperformed all non-learned baselines (Max-Pressure, Queue, Fixed Time) in throughput and completion.
  • Mannheim: It trailed the Queue baseline.
  • Heidelberg: It performed similarly to Fixed Time.
  • Freiburg: It achieved higher throughput and completion than Fixed Time but at the cost of higher wait density.
  • Note: Stuttgart served as the only true generalization test (no training rollouts), while the others demonstrated execution across heterogeneous training domains.

Significance and Claims

The paper explicitly frames its contribution as feasibility evidence rather than a general guarantee of transfer to arbitrary road networks.

• Modest Scope: The authors state that the results do not establish general transfer across arbitrary road networks. The evaluation is bounded to specific synthetic and city simulation families.
• Structural vs. Empirical: The paper distinguishes between the structural property (the ability to execute on variable graphs, which is proven by construction) and empirical robustness (which is shown to be sensitive to distribution shifts like signal coverage changes).
• Implementation Focus: The work evaluates an implementation and architectural interface rather than proposing a new reinforcement learning algorithm. It highlights that while the interface supports variable dimensions, the learned performance is not invariant to changes in the controller's distribution or the underlying network topology.

In conclusion, the paper demonstrates that a graph-based interface can successfully decouple learned movement scoring from local signal logic, enabling execution across diverse and unseen network geometries. However, it also reveals that structural executability does not automatically ensure robust performance under distribution shifts or across all heterogeneous city environments without further tuning or adaptation.