💻 computer science

Learning High-Level Decision Making with an Interaction-Aware Attention-Based Network in Autonomous Driving

This paper proposes DecisionPerceiver, an interaction-aware attention-based network inspired by Perceiver IO that projects dynamic agent features into a fixed-size latent space to achieve scalable, high-performance decision making for autonomous driving in complex, negotiation-intensive scenarios.

Original authors: Marcelo Contreras, Willi Poh, Christoph Stiller, Ehsan Hashemi

Published 2026-07-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Marcelo Contreras, Willi Poh, Christoph Stiller, Ehsan Hashemi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you're the captain of a self-driving car, but instead of a steering wheel, you have a super-smart brain that has to decide: "Do I speed up? Do I change lanes? Do I wait?" The tricky part is that the traffic around you is chaotic. Sometimes there are two cars, sometimes twenty, and they're all moving at different speeds.

For a long time, AI researchers tried to solve this by using a "DeepSet" approach. Think of this like a teacher who asks every student in a classroom to shout out their name, and then the teacher just takes the average of all those names to make a decision. It's simple and handles any number of students, but it's a bit clumsy. It misses the specific conversations happening between students. If the kid in the back is yelling at the kid in the front, the teacher just hears "noise" and misses the drama. This paper argues that for tricky situations like intersections, where cars have to "negotiate" who goes first, just averaging everything out isn't good enough.

On the other hand, there are "Attention" models. These are like a super-focused detective who looks at every single car and every single interaction at once. This is great for understanding the drama, but it's exhausting. If you add just a few more cars, the detective's brain has to do way more work—so much more that it gets slow and clunky. It's like trying to read every book in a library at the same time; if the library doubles in size, your reading time quadruples. That's too slow for a real car that needs to react instantly.

Enter the paper's new idea: DecisionPerceiver.

The authors built a system that acts like a brilliant translator. Instead of trying to listen to every single car directly (which is slow) or just averaging them all (which is dumb), the car projects all the surrounding traffic into a special, fixed-size "secret language" or latent space. Imagine the car has a small, magical notebook with a fixed number of pages (let's say 4 pages). No matter if there are 5 cars or 20 cars outside, the car quickly summarizes the most important interactions onto those 4 pages.

This is a game-changer because:

It keeps the drama: It still understands how cars are interacting with each other, unlike the "averaging" method.
It stays fast: Because the notebook is always the same size, the car doesn't get slower just because the traffic gets heavier. The "detective" doesn't have to read more books; they just update the same 4 pages.

The paper also suggests a clever tweak to the car's "action menu." Instead of just having big, clumsy buttons like "Turn Left" or "Go Faster," they added tiny, precise buttons like "Turn Half Left" or "Go Slightly Faster." Think of it like the difference between a video game character that only moves in giant, jerky steps versus one that can glide smoothly. This makes the car's movements much smoother and less stressful for the lower-level controls that actually steer the wheels.

What did they find?
The researchers tested this in a computer simulation (a virtual world, not real roads yet) across three different scenarios: a highway, a tricky intersection, and a roundabout.

On the Highway: The new system learned to drive fast and overtake others much quicker than the old methods. It reached a steady speed of 28.5 m s⁻¹ very early in its training, while other methods took much longer to catch up.
At the Intersection: This is where the "negotiation" matters most. The new system was the fastest, averaging 8.243 m s⁻¹, which is about 15.4% faster than the LFFDS method specifically. It figured out how to squeeze through traffic without crashing.
In the Roundabout: Here, the traffic is a bit simpler. The new system was slightly slower in raw speed (about 9.951 m s⁻¹) compared to some older methods, but it was much safer. It crashed or got stuck (early termination) at a rate 5 times lower than the others.

The paper also checked if the system could handle a crowd. They increased the number of cars the system had to watch from 5 up to 20. While the car did get a bit slower (dropping speed by 15%–30%) because the traffic was just denser and harder to maneuver, the system didn't break down. It kept working steadily, proving it can scale up without crashing.

In short, the authors suggest that by using this "translator" notebook to summarize traffic interactions and by giving the car more precise buttons to press, we can build self-driving policies that are both smart enough to handle complex traffic and fast enough to react in real-time. It's a promising step forward, but remember, all these results come from simulations, not real-world driving tests yet.

Technical Summary: DecisionPerceiver for High-Level Decision Making in Autonomous Driving

Problem Statement

Reliable learning-based high-level decision-making for autonomous driving (specifically lane changes and speed control) faces two primary challenges:

Variable Input Dimensions: Real-world traffic scenes involve a dynamically varying number of surrounding agents, requiring neural policies to handle inputs of non-fixed size without sensitivity to input ordering (permutation sensitivity).
Interaction Modeling vs. Scalability: Existing approaches struggle to balance explicit traffic interaction modeling with computational efficiency.
- DeepSets and variants handle variable inputs via shared encoders and permutation-invariant aggregation (e.g., pooling) but suffer from "feature collapse," losing explicit inter-agent interaction details crucial for negotiation-heavy scenarios like intersections.
- Attention-based methods (e.g., Transformers) effectively capture global dependencies and interactions but incur quadratic computational and memory complexity relative to input size, limiting real-time deployment. Additionally, they offer limited control over feature representation granularity.

Methodology

The paper proposes DecisionPerceiver, an interaction-aware, attention-based architecture designed to project dynamic agent features into a fixed-size latent space. The system is trained using a Reinforcement Learning (RL) framework.

1. Architecture: DecisionPerceiver

Inspired by Perceiver IO, the network decouples computational cost from input size:

Input Encoding: Dynamic agent states are encoded via a Multi-Layer Perceptron (MLP) and Layer Normalization to generate Keys ( $K$ ) and Values ( $V$ ). The ego-vehicle state is treated as a static input.
Latent Bottleneck: Instead of attending to all agents directly, the network projects these features into a fixed-size latent space ( $z \in \mathbb{R}^{N \times D}$ ) using a set of latent token queries ( $Q$ ).
Attention Mechanism: Multi-head attention is computed between the latent queries and the encoded agent features. This allows the model to regulate feature granularity via the number of latent queries ( $N$ ) while bounding complexity to the latent dimension rather than the number of agents.
Fusion and Output: The resulting interaction-aware latent representation is fused with the ego-state via an additional MLP. Separate network heads then regress the value function ( $V_\theta$ ) and the policy ( $\pi_\theta$ ).
No Pooling: Unlike DeepSets, no permutation-invariant collapsing operators (like pooling) are used, preserving the ability to learn inter-agent interactions.

2. Training Framework

Algorithm: The policy is optimized using Proximal Policy Optimization (PPO) within an Actor-Critic framework.
Objective: The loss function combines a clipped surrogate objective for the policy, a squared-error loss for the value function, and an entropy regularization term to encourage exploration.
Environment: Training and evaluation are conducted in the highway-env simulator across three scenarios: Highway (overtaking), Intersection (unprotected left turns), and Roundabout (merging/exit).

3. Refined Discrete Action Set

To reduce the burden on low-level lateral and longitudinal controllers, the standard discrete action set is extended with finer discretization:

Standard actions (e.g., "turn left") are split into intermediate levels (e.g., "turn half left," "turn full left").
This results in an augmented action space ( $A_{new}$ ) of nine discrete meta-actions.
This refinement aims to improve trajectory tracking by providing intermediate references, reducing control effort, and creating a more compact search space with reduced gradient variance.

Key Contributions

DecisionPerceiver Architecture: A novel behavioral planning architecture that maps dynamic-size inputs into a compact latent space. This enables scalable interaction modeling while avoiding the quadratic complexity growth associated with standard attention mechanisms.
Finer Action Discretization: The introduction of an expanded discrete action set with intermediate lateral and speed references. This improves low-level control performance and planner inference stability without sacrificing real-time capabilities.

Experimental Results

The proposed method was benchmarked against state-of-the-art baselines: DeepSet, LFFDS (a DeepSet variant), and Ego-attention.

Performance Metrics

Highway Scenario: DecisionPerceiver achieved the highest average velocity (29.25 m/s), outperforming DeepSet by ~6.2% and LFFDS by ~4.2%. It demonstrated rapid convergence, reaching steady performance at $1 \times 10^5$ steps, whereas Ego-attention required $5 \times 10^5$ steps.
Intersection Scenario: DecisionPerceiver attained the highest average speed (8.243 m/s), a 15.4% relative gain over the next best baseline (LFFDS). While Ego-attention achieved a slightly higher reward and lower early termination rate, DecisionPerceiver maintained a more aggressive high-speed policy.
Roundabout Scenario: DecisionPerceiver achieved a velocity of 9.951 m/s. While slightly lower in speed than DeepSet and LFFDS (by ~5% and ~1% respectively), it recorded a significantly lower early termination rate (near zero compared to ~5% for others) and a higher reward score, indicating a safer policy.

Ablation Studies

Action Discretization: In the Highway scenario, the finer discretization led to a steady increase in accumulated reward and higher average speeds compared to the original action set, attributed to reduced reaction times and collision likelihood in the low-level controller.
Scalability: The model maintained stable and competitive performance as the number of observable vehicles increased from 5 to 20. While average speed decreased by 15–30% due to increased traffic density and collision risk, the architecture did not suffer catastrophic degradation, demonstrating scalability to denser traffic.

Significance and Claims

The paper claims that DecisionPerceiver offers a balanced solution for high-level behavioral planning by:

Enabling Scalable Interaction Modeling: By projecting interactions into a fixed latent space, the model captures complex traffic dependencies without the computational prohibitions of full attention mechanisms.
Improving Control Efficiency: The finer action discretization bridges the gap between high-level planning and low-level execution, reducing control effort and improving trajectory tracking.
Demonstrating Robustness: The method consistently outperforms or matches state-of-the-art set-based and attention-based baselines across diverse operational conditions, showing particular strength in negotiation-intensive scenarios (intersections) and high-speed overtaking (highways).

The authors conclude that the approach yields superior performance in complex traffic environments, offering improved scalability and representation flexibility compared to existing methods.