🤖 AI

A Generative Model for Closed-Loop Microsimulation of Signalized Intersections

The paper introduces Enactor, an actor-centric generative model that utilizes a closed-loop training curriculum and polar coordinate encoding to achieve stable, high-fidelity microsimulation of signalized intersections, significantly outperforming existing baselines in reproducing traffic distributions and reducing safety violations.

Original authors: Yash Ranjan, Rahul Sengupta, Anand Rangarajan, Sanjay Ranka

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yash Ranjan, Rahul Sengupta, Anand Rangarajan, Sanjay Ranka

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 a busy intersection as a giant, chaotic dance floor. For decades, computer scientists have tried to simulate this dance using "hand-crafted" rules. They programmed the digital cars to act like perfect, polite robots: "If the light is red, stop. If the car ahead slows down, slow down." These simulations are great for counting how many cars pass through a city in an hour, but they fail to capture the messy, human reality of traffic: the aggressive lane changes, the distracted drivers, and the split-second decisions that happen when a pedestrian steps near the curb.

Enter Enactor, a new AI model introduced in this paper. Think of Enactor not as a rule-book, but as a student dancer who learns by watching real footage and then practicing the dance over and over again until it gets the rhythm right.

Here is how the paper breaks down this new approach:

1. The "Closed-Loop" Dance Practice

Most AI models that predict where a car will go are like a student who practices a dance move once, gets it right, and then stops. They are "open-loop." But traffic is a continuous loop.

Enactor is trained in a "closed-loop" environment. Imagine a student who practices a dance routine, makes a mistake, and then has to keep dancing based on that mistake to see if they can recover. Enactor is forced to control every single car in the simulation for 4,000 seconds (over an hour) without stopping. If it predicts a car will turn left, the simulation actually turns the car left, and the AI must then predict what happens next based on that new reality. This prevents the AI from "drifting" into nonsense over time.

2. Seeing the World Through a "Polar" Lens

To understand the intersection, Enactor doesn't use a standard map grid (like a chessboard). Instead, it uses polar coordinates, which is like seeing the world from the center of the intersection looking outward in a circle.

The Analogy: Imagine standing in the middle of a roundabout. You don't think in "up, down, left, right." You think in "how far away is that car?" and "what angle is it coming from?" This helps the AI understand the curved paths cars take at intersections much better than a standard grid does.

3. The "Rear Bumper" Secret Ingredient

The paper found one specific trick that made a huge difference: giving the AI a view of the rear bumper of the car in front.

The Analogy: Imagine you are driving and you have to stop at a red light. If you can't see the bumper of the car in front of you, you might stop too early or roll too far past the line. Enactor is explicitly told, "Here is exactly where the car ahead's bumper is." This simple piece of geometric information taught the AI exactly where to stop, drastically reducing "red-light violations" (running the light) compared to previous models.

4. Two Different Tests

The researchers tested Enactor in two very different ways:

Test A: The Perfect Simulator (SUMO)
They created a digital twin of a real intersection in Gainesville, Florida. They let Enactor control every car for 4,000 seconds.
- The Result: Enactor produced traffic patterns (speed and travel time) that looked almost exactly like the real world. It ran the simulation with far fewer "red-light violations" and "near-miss" accidents than the previous best AI model. It was stable enough to keep the traffic flowing for an hour without the simulation crashing or the cars driving off the road.
Test B: The Real-World Camera
They pointed a fisheye camera at a real intersection and fed the video into Enactor.
- The Challenge: Real camera data is "noisy." The AI might see a car jitter left and right because of camera glitches, not because the car is actually swerving.
- The Result: They tested two versions: one that smoothed out the camera jitter (like a photo filter) and one that didn't. Both versions were much better at predicting where a car would be in 2, 5, or 10 seconds compared to a simple "constant velocity" guess (which just assumes the car keeps going straight at the same speed).

5. What It Still Can't Do

The paper is honest about its limitations. While Enactor is great at the "big picture" (how fast traffic flows) and following the rules (stopping at lights), it still struggles with close-range interactions.

The Analogy: Enactor is good at knowing the general flow of the dance floor, but if two dancers get very close to each other, it sometimes miscalculates how close they will get before they have to stop. The paper notes that predicting these split-second, "time-to-collision" moments is still an open problem.

Summary

Enactor is a new way to simulate traffic intersections. Instead of hard-coding rules, it uses a neural network (a type of AI) that learns by watching cars, using a special "circular" view of the world, and paying close attention to the bumper of the car in front. It proved it could run a stable, hour-long simulation of a busy intersection, following traffic laws much better than previous AI, and could also predict real-world car movements better than simple guessing.

Technical Summary: A Generative Model for Closed-Loop Microsimulation of Signalized Intersections

Problem Statement
Traffic microsimulators (e.g., SUMO) traditionally rely on hand-crafted behavior models that reproduce aggregate flow but fail to capture the heterogeneous, sometimes aggressive interactions between vehicles at signalized intersections. Conversely, learned trajectory predictors capture richer interactions but are typically short-horizon, evaluated open-loop, and unstable when run in closed-loop over long horizons due to error compounding. Furthermore, existing data-driven approaches often struggle to model physically plausible, socially consistent behavior without massive datasets, and few address the specific structural constraints of intersections (signals, lane topology, geometry) while maintaining a non-stationary actor cohort (vehicles entering and leaving continuously).

Methodology: Enactor
The authors propose Enactor, an actor-centric generative model designed for closed-loop microsimulation of signalized intersections. Key architectural and training components include:

State Representation: The model utilizes a polar-coordinate state representation aligned with intersection geometry. Each actor's state is defined as $(r, \sin \theta, \cos \theta, s, \sin \alpha, \cos \alpha)$ , where $r$ is the radial distance from the intersection center, $\theta$ is the angular position, $s$ is linear speed, and $\alpha$ is heading. Static elements (lanes) are encoded as polylines, and traffic signals are represented as lane-end vectors with one-hot phase encoding.
Input Features: A critical innovation is the inclusion of the leader's rear-bumper position as an explicit input feature for each actor. This geometric cue provides a reference for where deceleration should terminate, addressing the "stop-line" problem. Pedestrians are included as contextual neighbors influencing vehicle attention but are not predicted as primary targets.
Architecture: Enactor employs a Transformer-based architecture with two sequential attention blocks:
1. Spatial Block: Captures actor-actor and actor-map interactions at each timestep using self-attention over neighbors, map polylines, and signal vectors.
2. Temporal Block: Aggregates spatial embeddings over a history window to predict a distribution over the next-step motion parameters (speed $s$ and heading change $\alpha$ ).
Output & Kinematics: The model outputs a mixture-of-Gaussians distribution over $(s, \alpha)$ . At inference, a sample is drawn, and the actor's next position is computed via a deterministic kinematic update.
Training Regime: The model is trained using a closed-loop curriculum. Initially, the model receives ground-truth context; progressively, ground-truth context is replaced by the model's own predictions. This mitigates covariate shift, ensuring the model learns to rely on its own predictions during inference.
Evaluation Regimes:
1. Simulator Regime: A "simulation-in-the-loop" test where Enactor controls all dynamic vehicles for 4,000 seconds (40,000 timesteps) against a continuously refreshing actor cohort at two intersection geometries.
2. Real-World Regime: Evaluation on naturalistic data from a fish-eye camera using a single-pass, multi-horizon predictive protocol (2s, 5s, 10s). The study also investigates the impact of preprocessing (spline smoothing) on trajectory noise.

Key Contributions

Geometry-Aware Representation: A polar-coordinate state representation specifically aligned with intersection geometry.
Closed-Loop Microsimulation: A transformer-based generative model trained and evaluated as a full microsimulator, sustaining stable rollouts over 4,000 seconds against a non-stationary actor cohort, distinct from standard fixed-cohort evaluations.
Leader Rear-Bumper Feature: An ablation study isolating the leader's rear-bumper position as the single input feature with the largest effect on intersection-aware safety metrics (specifically rule compliance).
Comprehensive Evaluation: A direct comparison against the IntTrajSim baseline under identical closed-loop protocols, alongside evaluation on real-world field data.
Noise Analysis: An empirical investigation into the effects of upstream detection noise (lateral drift) and the trade-offs of spline smoothing for training inputs.

Results

Aggregate Flow Realism: In the simulator regime, Enactor recovers the SUMO data generator's speed and travel-time distributions with significantly lower KL divergence than the IntTrajSim baseline (over an order of magnitude lower on travel time; roughly 5× lower on speed at Site 1).
Rule Compliance: Enactor reduces red-light violations by more than an order of magnitude compared to IntTrajSim (5 violations vs. 169/175 at Site 1). The ablation study confirms that removing the leader rear-bumper feature causes a significant degradation in rule compliance (199 violations), highlighting its necessity for accurate stopping behavior.
Safety Metrics: While Enactor improves red-light compliance, Time-to-Collision (TTC) events remain higher than raw SUMO data, indicating that close-range interaction realism is still an open problem.
Real-World Performance: On naturalistic data, both Enactor-Smooth and Enactor-Raw outperform constant-velocity baselines at all horizons (2s, 5s, 10s). Enactor-Smooth shows a slight edge at 2 seconds, while Enactor-Raw performs better at longer horizons (5s, 10s) regarding Final Displacement Error (FDE) and within-threshold success rates, suggesting a trade-off between removing jitter and introducing smoothing bias.

Significance and Claims
The paper argues that stable long-horizon closed-loop rollout, aggregate-flow realism, and intersection-aware safety realism are distinct objectives requiring different design choices.

The polar representation and closed-loop curriculum primarily address stability and aggregate flow.
The leader rear-bumper feature is identified as the critical component for intersection-aware safety (rule compliance).
The authors claim that Enactor successfully bridges the gap between short-horizon trajectory prediction and long-horizon microsimulation, demonstrating that a learned model can control a dynamic, non-stationary traffic scene for thousands of timesteps without diverging from the road network.
The paper modestly acknowledges that close-range interaction realism (specifically minimizing TTC events) remains the primary limitation of the current model.
Regarding real-world deployment, the authors note that while the architecture works on naturalistic data, online deployment would require a causal preprocessing pipeline and broader field validation, as the current smoothing approach is not causal.