Self-driving cars need a map of which lanes feed into which: a directed graph over lane centerlines at every intersection. Current systems use transformer detectors that predict each lane on its own, from a learned "query" vector (a slot the decoder fills in with one object). A separate small network then guesses whether lane A connects to lane B. This design is structurally blind. Connectivity is inferred from two abstract embeddings, so if a predicted endpoint drifts by a few centimeters the connection is lost. TopoLogic showed how large this failure is: an explicit endpoint-distance check applied after the fact to a trained TopoNet raised lane-to-lane topology from 10.9 to 22.3 on OpenLane-V2 without any retraining. The field has since patched the symptom. Distance checks are added afterward, and TopoPoint snaps endpoints to lane tips at inference. Topology is still something the model infers after detection, not something built into how lanes are represented.
We propose to reverse the order. First, a network predicts heatmaps of graph nodes: lane start points, end points, merges and forks in the bird's-eye-view plane. Then each lane query is created from a pair of detected node peaks. Two lanes connect exactly when they share a node index, so connectivity follows from how queries are built and no classifier has to guess it. This borrows the heatmap-peak query initialization of CenterFormer and applies it to relational structure. The design has a new failure mode: early in training the node heatmap is noisy, and one missed node silently deletes every lane touching it. We handle this with a curriculum. Queries start anchored on jittered ground-truth nodes, and the decoder is moved onto its own predicted peaks at a pace set by how reliable the heatmap has become, not by a fixed epoch count.
Core Claim
On lane topology reasoning, the brittleness to endpoint shift comes from representing lanes as independent objects. Representing lanes as edges between shared, heatmap-detected nodes should remove most of it inside the model, not in post-processing. We also claim that this representation can only be trained stably with a reliability-paced handoff from ground-truth nodes to predicted nodes. The concrete, falsifiable prediction has two parts. First, the node-anchored model should match or exceed TopoPoint plus TopoLogic-style post-processing on lane-to-lane topology on OpenLane-V2 subset_A. Second, its topology score should degrade markedly less under synthetic endpoint perturbation, with the gains concentrated at intersections of degree three or more.
Relation to Prior Work
Three lines of work motivate the design. OpenLane-V2 defines the benchmark and reports that detection quality bottlenecks topology. TopoLogic shows that learned connectivity heads fail under endpoint shift and that geometric distance repairs much of the damage. Its fix is a tolerance function applied to already-decoded lanes; we instead make shared endpoints structural. TopoPoint is the closest existing work and our main competitor. It adds explicit endpoint queries, distance-biased attention between points and lanes, a point-lane graph convolution, and a post-hoc geometry-matching step that snaps endpoints onto lane tips. Its point and lane queries are still initialized as fixed learned sets, and its lanes remain separate objects that are reconciled with points afterward. The paper itself notes sensitivity to fixed query counts. Our lanes do not have endpoints of their own; they are a pair of node indices.
Heatmap-guided initialization supplies the method. CenterFormer takes encoder features at the top center-heatmap peaks as queries and reports a 1.5 mAPH gain over learned slots on Waymo. Deformable DETR shows that seeding queries from encoder proposals cuts training from 500 to 50 epochs on COCO. Both treat each peak as an isolated object; we use pairs of peaks as relational queries. RNGDet is the nearest graph-building analogue. It supervises intersection and segment masks and grows a road graph vertex by vertex from seed points using imitation learning. Our construction is instead one-shot and global over all detected nodes, which avoids the error accumulation of step-by-step tracing.
The curriculum builds on Self-Paced Learning for Latent Variable Models, which admits training samples as the model's error on them falls. We apply the same idea to the source of queries instead of to samples. QueryCraft constrains our design. It avoids the chicken-and-egg problem of learning proposals and decoder together by using a frozen pretrained detector. That suggests a plain freeze-then-train pipeline might be enough, and we test that directly instead of assuming the curriculum is needed. Graph-to-MLP distillation work such as VQGraph also tackles structural blindness, but on abstract citation and molecule graphs with known edges. We cite it only as evidence that flat models fail on relational targets, not as a method we reuse.
Research Program
The model keeps a standard multi-camera bird's-eye-view encoder, as in the TopoNet and TopoPoint lineage, so that the comparison isolates the query design. A node head predicts a heatmap of lane-graph nodes. In OpenLane-V2, a node is a cluster of ground-truth centerline endpoints that the annotated topology marks as connected, so merges and forks become single nodes. After peak extraction we keep up to $N$ nodes $p_1,\dots,p_N$ with features $f(p_i)$ sampled from the bird's-eye-view map. Because all $N^2$ pairs would be too many, a lightweight pair scorer keeps the top $K$ directed pairs, using a learned score over the two node features and their displacement. Each kept pair becomes a lane query
$$q_{ij} = g\big(f(p_i),\, f(p_j),\, p_j - p_i\big),$$
where $g$ is a small network. The decoder then refines only the lane's interior shape as a curve pinned at $p_i$ and $p_j$. Node positions are also refined, but by a shared node update, so every lane touching a node moves with it.
The predicted topology is read off directly. The edge "lane $(i,j)$ feeds lane $(j,k)$" exists whenever both lane queries survive the decoder's confidence threshold. Lane-to-traffic-element association keeps the existing head unchanged. Set matching is done at the lane level as usual. We add a node-level matching loss so that lane supervision flows back into node quality.
The curriculum governs which nodes seed the queries. At each training step, a fraction $\lambda$ of anchor nodes comes from ground truth with Gaussian jitter of scale $\sigma$. The remaining $1-\lambda$ come from predicted peaks. Both $\lambda$ and $\sigma$ are driven by the node head's running recall at a fixed radius, $r_t$. We set $\lambda_t = 1 - r_t$, and $\sigma$ is annealed toward the head's measured localization error. The handoff is therefore complete when, and only when, the heatmap has become trustworthy. At inference, only predicted peaks are used.
A secondary analysis tests whether structural difficulty should also be staged. In that variant, scenes are ordered by the maximum node degree in their ground-truth graph, and complex intersections are admitted over training. This follows Gap 3 in our notes and the easy-to-hard argument of A Task-centric Theory for Iterative Self-Improvement with Easy-to-Hard Curricula. We treat it as a hypothesis to test, not as part of the method.
Baselines
The naive reference point is TopoNet as reported on subset_A. TopoLogic gives it 39.8 OLS (the overall OpenLane-V2 score) and 10.9 lane-to-lane topology. The benchmark paper, OpenLane-V2, reports 35.4 OLS for TopoNet, and we will state which protocol version we match. This baseline shows what learned slots plus a connectivity classifier achieve.
The strongest existing method is TopoPoint, reported at 48.8 OLS and 52.6 endpoint detection on subset_A. The file gives no TopoPoint lane-to-lane topology number; no reported result was found on Lacuna for TopoPoint's topology score, so we will retrain it and measure it. It is the right competitor because it already makes endpoints explicit and couples them to lanes with a graph convolution; it differs from us only in keeping lanes as separate objects and repairing consistency afterward. We will also run TopoPoint with TopoLogic's distance-based connectivity added on top. That combination is the strongest "post-hoc repair" system we can assemble, and TopoLogic alone is reported at 23.9 topology and 44.1 OLS. All systems will share our backbone, image resolution, SD-map inputs, training epochs and a matched hyperparameter search budget. Beating the strongest baseline means exceeding TopoPoint plus distance post-processing on lane-to-lane topology and OLS by more than the seed-to-seed spread over three seeds, without losing more than one point of endpoint detection.
Three ablations isolate the key ingredients. The first keeps pair-based queries but builds edges with TopoLogic's distance function instead of shared node indices; this isolates "structure by construction" from "heatmap seeding." The second trains the full model with no curriculum, using predicted peaks from step one. The third uses a fixed epoch-based schedule for $\lambda$ instead of the reliability-paced one.
Why not just…?
Why not just add TopoLogic's distance check to TopoPoint? This is the most serious threat. TopoLogic's post-processing alone roughly doubled TopoNet's topology score, and TopoPoint's snapping already produces aligned endpoints. If our node-anchored model does not beat that combination on clean data, the representational change is not worth its complexity. Our argument rests on robustness. Post-hoc tolerance absorbs small shifts but has a fixed radius, so it should fail once shifts exceed its plateau. It also cannot recover a connection whose endpoints were never decoded close enough. The endpoint-perturbation sweep described below will settle this.
Why not just pretrain the heatmap head, freeze it, and then train the decoder? This is the QueryCraft recipe of relying on a frozen proposal source, and it may work as well as our curriculum. If it does, we will drop the curriculum and report the simpler pipeline. We expect it to fall short for two reasons. The frozen heatmap never receives lane-level feedback about which nodes matter for topology. And a decoder trained only on one fixed error profile has no exposure to the cleaner node sets it would see in easy scenes. The comparison uses matched total epochs.
Why not just train with ground-truth-jittered queries throughout, the way detectors add noised ground-truth boxes as an auxiliary task? Training only on ground-truth anchors leaves a gap at test time, when every node is predicted. Keeping both sources without pacing is close to our fixed-schedule ablation. The reliability-paced variant has to beat both an always-mixed setting and a fixed schedule to justify itself.
Why not just sort scenes from simple to complex intersections? A scene-level curriculum over graph complexity is cheaper and addresses a different difficulty: combinatorics, not noisy anchors. We run it both alone and combined with our method. If it alone recovers most of the gain, the story changes, and the paper would report that.
Proposed Experiments
The main benchmark is OpenLane-V2 subset_A, with subset_B used to check transfer to a sensor setup without SD maps. We report OLS, lane detection, endpoint detection, lane-to-lane topology and lane-to-traffic-element topology.
The first decisive check is an endpoint-shift sweep. We perturb predicted node or endpoint positions by controlled offsets from centimeters to about a meter, then plot topology score against offset for every system. Our claim predicts a flatter curve than TopoPoint plus distance post-processing, especially beyond the tolerance plateau.
The second check stratifies topology accuracy by ground-truth node degree. If sharing nodes is what helps, the gains should concentrate at forks and merges, not on simple lane continuations.
The third check tracks node recall, lane-matching stability (how often a ground-truth lane's matched query changes between iterations) and topology score over training, with and without the curriculum. This tests whether the curriculum actually removes early instability or merely delays it.
As a secondary test of generality, we apply the same node-pair construction to aerial road-graph extraction on RoadTracer. There, RNGDet reports 67.88 APLS (a path-length similarity score), versus 63.76 for VecRoad and 63.21 for Sat2Graph. The question is whether one-shot node-pair decoding can match iterative tracing, including at occluded intersections.
A negative outcome on the first check, meaning parity with post-hoc repair under perturbation, would falsify the core claim.
References
- TopoLogic: An Interpretable Pipeline for Lane Topology Reasoning on Driving Scenes
- TopoPoint: Enhance Topology Reasoning via Endpoint Detection in Autonomous Driving
- CenterFormer: Center-Based Transformer for 3D Object Detection
- OpenLane-V2: A Topology Reasoning Benchmark for Unified 3D HD Mapping
- Deformable DETR: Deformable Transformers for End-to-End Object Detection
- RNGDet: Road Network Graph Detection by Transformer in Aerial Images
- Self-Paced Learning for Latent Variable Models
- QueryCraft: Transformer-Guided Query Initialization for Enhanced Human-Object Interaction Detection
- VQGraph: Rethinking Graph Representation Space for Bridging GNNs and MLPs
- A Task-centric Theory for Iterative Self-Improvement with Easy-to-Hard Curricula