⚡ electrical engineering

End-to-end differentiable network traffic simulation with dynamic route choice

This paper introduces UNsim, an open-source, end-to-end differentiable network traffic simulator based on the Link Transmission Model and dynamic user optimum route choice that leverages automatic differentiation to efficiently compute exact gradients for large-scale optimization problems without requiring smooth relaxation or manual derivation.

Original authors: Toru Seo

Published 2026-04-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Toru Seo

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 are the mayor of a massive, bustling city. Your goal is to keep traffic flowing smoothly. But here's the problem: the city is so big, and the drivers are so unpredictable, that you can't just guess what will happen if you change a traffic light, add a toll, or widen a road.

Traditionally, traffic engineers have had to play a game of "guess and check." They would tweak a setting, run a simulation, see the result, tweak it again, and repeat. It's like trying to find the perfect temperature for a shower by turning the knob, waiting, feeling it, turning it again, and waiting. It takes forever, especially when you have thousands of knobs to turn.

This paper introduces a revolutionary new tool called "UNsim" that changes the game entirely.

Here is the simple breakdown of what the author, Toru Seo, has built:

1. The Old Way vs. The New Way

The Old Way (Black Box): Imagine a traffic simulator as a mysterious black box. You put numbers in (like "how many cars are coming"), and it spits out numbers out (like "how long the trip takes"). If you want to know how changing the speed limit affects the trip, you have to run the whole simulation again with a slightly different speed limit. If you have 15,000 things to change (like tolls on every road), you'd have to run the simulation 15,000 times just to figure out the direction to move. It's slow and inefficient.
The New Way (The "Magic Mirror"): The author built a simulator that isn't a black box; it's a transparent, self-aware machine. It doesn't just tell you the result; it tells you exactly how every single input contributed to that result. It's like having a magic mirror that, when you look at the traffic jam, instantly whispers, "If you lower the toll on Main Street by $1, traffic will clear up by 5%."

2. How Does It Work? (The "Cumulative Counter" Trick)

Most traffic simulators try to track every single car like a video game character. This is hard to do mathematically because a car making a "left turn" is a discrete, binary decision (Left or Right? Yes or No?). Math hates "Yes or No" questions when trying to calculate smooth changes.

The author's secret sauce is the Link Transmission Model (LTM). Instead of tracking individual cars, this model tracks cumulative counts.

The Analogy: Imagine a water pipe. Instead of counting every single water droplet, you just measure the total volume of water that has passed a point.
Because the model deals with smooth, continuous numbers (like water volume) rather than jagged, discrete steps (like "car 1 turned left"), the math becomes smooth. The author realized that even though traffic jams look chaotic, the underlying math of "how many cars have entered" and "how many have left" is actually very smooth and predictable. This allows the computer to use Automatic Differentiation—a fancy math trick that calculates the "slope" of the traffic flow instantly, without needing to guess.

3. The "Smart Driver" (Dynamic Route Choice)

The hardest part of traffic simulation is that drivers change their minds. If a road is jammed, they take a detour.

The Challenge: Usually, if you change a road condition, you have to re-calculate which path every driver takes. This is a "discrete" jump (Driver A switches from Path X to Path Y), which breaks the smooth math.
The Solution: The author built a "Dynamic User Optimum" (DUO) model. It assumes drivers are smart and always pick the fastest route right now.
The Magic: Even though drivers switch routes, the author found a way to make the percentage of drivers taking a route change smoothly. It's like a crowd of people at a crosswalk: if one path gets slightly slower, a fraction of the crowd shifts to the other path. This smooth shift allows the computer to calculate the "gradient" (the direction to improve) instantly.

4. The Real-World Test: Chicago

To prove it works, the author tested this on the Chicago-Sketch dataset, a massive network with:

2,500 roads
1 million vehicles
15,000 variables (like toll prices for every road at different times of day)

The Result:

Old Method: Would take days or weeks to find a good solution.
New Method (UNsim): Solved the problem in 2 hours.
Speed: One full simulation and gradient calculation took only 0.8 seconds.
Outcome: The system found a "perfect" toll plan that reduced total travel time by 55%. It figured out exactly where to charge money to keep traffic moving, essentially "learning" the best traffic control strategy on its own.

5. Why Should You Care?

Think of this as GPS for City Planning.

For Cities: It means we can design better traffic systems, set fair tolls, and fix congestion much faster.
For the Future: Because this simulator is "differentiable" (it can calculate its own gradients), it can be plugged into Artificial Intelligence. Imagine an AI that doesn't just guess traffic patterns but learns the physics of traffic directly, combining human data with the laws of physics to create the ultimate traffic controller.

In a nutshell: The author built a traffic simulator that is so mathematically smooth and self-aware that it can instantly tell you how to fix a traffic jam, even in a city the size of Chicago, turning a task that used to take weeks into a task that takes minutes. It's like giving city planners a superpower to see the future of traffic and fix it before it happens.

1. Problem Statement

Network traffic simulation is essential for tasks like demand estimation, parameter calibration, and network optimization. However, a major bottleneck exists in computing gradients (sensitivities) of simulation outputs (e.g., total travel time) with respect to model inputs (e.g., demand, road capacity, tolls).

Conventional Limitations:
- Derivative-free methods (e.g., SPSA, Genetic Algorithms) are computationally inefficient for high-dimensional parameter spaces.
- Adjoint methods provide exact gradients but require labor-intensive manual derivation for every specific model formulation, making them hard to maintain.
- Differentiable Simulation (Existing): Previous attempts in traffic have been limited to single links, simplified networks, or agent-based models that require "smooth relaxations" of discrete decisions (like route choice), which can compromise physical accuracy and gradient quality.
Core Challenge: How to create a network-scale traffic simulator that supports endogenous dynamic route choice (where travelers choose paths based on real-time congestion) while remaining fully differentiable without significant approximations that alter model behavior.

2. Methodology

The author proposes UNsim, an end-to-end differentiable macroscopic traffic flow simulator implemented in Python and JAX. The framework combines three core components:

A. Traffic Flow Model: Link Transmission Model (LTM)

Basis: The simulator uses the LTM, which solves the Lighthill-Whitham-Richards (LWR) kinematic wave theory using cumulative vehicle counts ( $N(t, x)$ ) rather than discrete vehicle trajectories.
Differentiability: The LTM operates on continuous aggregate state variables. The core operations are piecewise-linear min/max functions (derived from demand-supply constraints and Newell's simplified kinematic wave theory).
Key Insight: Min/max operations are differentiable almost everywhere (admitting subgradients at kink points). This allows the use of Automatic Differentiation (AD) without needing smooth relaxations (like sigmoid approximations) that would distort the physics of traffic flow.

B. Node Models

The simulator handles complex network topologies using a suite of node models:

Origin/Destination, Dummy, Diverge, Merge: Standard models based on demand/supply constraints.
General Nodes: Uses the Incremental Node Model (INM) for complex intersections.
Differentiable Reformulation: The INM is an iterative algorithm. To make it differentiable, the author reformulates it as a fixed-length scan (unrolling the loop) where each step involves only arithmetic and min/max operations. This creates a static computation graph compatible with AD.

C. Dynamic Route Choice (DUO)

Model: Implements Dynamic User Optimum (DUO), where travelers choose the instantaneous shortest path based on current congestion.
Challenge: Shortest path algorithms (e.g., Bellman-Ford, Dijkstra) involve discrete decisions, which break differentiability.
Solution:
1. Continuous Aggregation: The model tracks per-destination cumulative counts. The diverge ratios (flow splitting at nodes) are calculated as continuous functions of these counts.
2. Gradient Flow: Even though the shortest path tree is discrete, the diverge ratios used in the flow propagation are continuous functions of the state variables. Gradients flow through the weights of the path aggregation.
3. Logit Extension: To handle cases where gradients might be zero (due to path switching discontinuities), a Logit-based DUO is introduced. This provides a probabilistic route choice that is smooth and differentiable everywhere, ensuring non-zero gradients for optimization.

D. Implementation Details

Reverse-Mode AD: Computes exact gradients in a single backward pass, regardless of the number of parameters ( $O(1)$ cost relative to parameter dimension).
Virtual Trajectories: Despite being macroscopic, the model recovers individual vehicle travel times via the FIFO property of cumulative counts, enabling trip-level objective functions.
Hardware: Utilizes GPU acceleration via JAX for massive parallelization of node models and time steps.

3. Key Contributions

First End-to-End Differentiable Network Simulator with DUO: This is the first work to formulate a network-scale traffic simulator with endogenous dynamic route choice that is fully differentiable without compromising the physical properties of the LWR model.
Exact Gradients without Relaxation: By leveraging the mathematical properties of the LTM (min/max operations on cumulative counts), the model avoids the "smooth relaxation" pitfalls of previous agent-based differentiable simulators.
Scalability: The method computes gradients in a single backward pass, making it feasible to optimize problems with tens of thousands of decision variables (e.g., dynamic tolls on thousands of links).
Open Source Release: The simulator, UNsim, is released as open-source software, providing a foundation for physics-informed deep learning in transportation.

4. Numerical Results

The paper validates the model through two experiments:

A. Toy Network (Y-shaped Merge)

Goal: Verify the qualitative correctness of computed partial derivatives.
Findings:
- Derivatives of Total Travel Time (TTT) with respect to demand were positive (increasing demand increases TTT).
- Derivatives with respect to free-flow speed were negative (increasing speed decreases TTT).
- Derivatives with respect to merge priorities showed expected symmetric effects on upstream links.
- Conclusion: The gradients are physically consistent and accurate, confirming the AD implementation works correctly.

B. Chicago-Sketch Network (Large-Scale Optimization)

Setup:
- Scale: ~2,500 links, ~1 million vehicles, 17,963 OD pairs.
- Task: Dynamic congestion pricing optimization (determining time-varying tolls for 383 links over 40 time periods = 15,320 decision variables).
- Hardware: NVIDIA GH200 GPU.
Performance:
- Speed: One forward simulation + backward gradient pass took ~0.8 seconds.
- Optimization: Solved in 10,000 iterations (approx. 2 hours total).
Outcome:
- TTT Reduction: Achieved a 55.7% reduction in total travel time compared to the no-toll scenario.
- Convergence: The objective function and TTT converged stably.
- Physical Insight: The resulting toll pattern naturally formed a "perimeter control" strategy, charging higher tolls in the downtown congested core. Macroscopic Fundamental Diagram (MFD) analysis showed the optimized scenario kept the network in the free-flow regime, avoiding hysteresis and increasing throughput.

5. Significance and Future Directions

Paradigm Shift: This work bridges the gap between traditional traffic engineering (physics-based models) and modern machine learning (differentiable programming). It allows for the direct application of gradient-based optimizers (like Adam) to complex traffic control problems.
Applications: Beyond congestion pricing, the framework is applicable to:
- OD demand estimation.
- Fundamental Diagram parameter calibration.
- Network design (capacity expansion).
- Traffic signal and ramp metering optimization.
Hybrid Modeling: The differentiable nature allows for the integration of neural networks with physical models (Physics-Informed Machine Learning), e.g., using NNs to learn complex demand patterns while keeping the LTM as the physical backbone.
Limitations & Future Work: The author notes that "zero gradients" can occur in specific regimes (e.g., free-flow where capacity changes don't affect travel time), which can stall gradient-based optimizers. Future work may involve tailored optimization algorithms or artificial viscosity to smooth these plateaus.

In summary, UNsim represents a significant advancement in traffic simulation by enabling efficient, exact, and scalable gradient-based optimization for large-scale dynamic networks with realistic route choice behavior.