LightSim: A Lightweight Cell Transmission Model Simulator for Traffic Signal Control Research

1. Problem Statement

Reinforcement Learning (RL) for traffic signal control is currently bottlenecked by the limitations of existing microscopic traffic simulators, primarily SUMO and CityFlow. While these tools offer high-fidelity vehicle-level dynamics, they introduce significant overhead for RL research:

• Installation & Configuration: They require complex platform-specific binaries, C++ compilation, and intricate XML network/route configurations, creating a high barrier for RL researchers.
• Simulation Speed: Inter-process communication (IPC) between Python RL agents and external simulator processes creates a bottleneck, particularly for on-policy algorithms requiring millions of environment interactions.
• Reproducibility: Differences in versions, network formats, and platform behaviors make reproducing published results difficult.
• Iteration Cycle: Training in SUMO can take hours, discouraging rigorous multi-seed experiments and rapid hyperparameter tuning.

The authors argue that for signal timing optimization, the critical dynamics are queue formation and discharge at intersections, not individual vehicle trajectories. Therefore, a macroscopic model capable of capturing these specific dynamics with high computational efficiency is sufficient and preferable for algorithmic research.

2. Methodology: LightSim

The authors propose LightSim, a pure-Python, pip-installable traffic simulator built on the Cell Transmission Model (CTM).

Core Traffic Dynamics (CTM)

• Model: LightSim discretizes road links into cells of length $\Delta x = v_f \cdot \Delta t$. Traffic is modeled as a continuum fluid using density ($k$) and flow variables.
• Fundamental Diagram: It utilizes a triangular fundamental diagram governed by free-flow speed ($v_f$), backward wave speed ($w$), jam density ($k_j$), and capacity ($Q$).
• Flow Computation: Flow between cells is determined by sending ($S$) and receiving ($R$) functions, taking the minimum of supply and demand.
• Intersection Logic: Signal phases modulate flow via a binary mask. Turn ratios and saturation rates are applied to calculate movement flows, ensuring vehicle conservation at merges and diverges.
• Numerical Stability: The discretization satisfies the Courant–Friedrichs–Lewy (CFL) condition.

Architecture & API

• Implementation: The core engine uses vectorized NumPy operations on flat arrays, eliminating the need for external binaries or IPC.
• Interfaces:
  • Gymnasium: For single-agent control (single intersection).
  • PettingZoo: For multi-agent control (grid networks), where each intersection is an independent agent.
• Extensibility: Supports pluggable components for observations (e.g., pressure, density), actions (phase selection), and rewards (queue, delay, throughput).

Mesoscopic Extensions

To bridge the fidelity gap with microscopic simulators, LightSim introduces two backward-compatible extensions (disabled by default):

1. Start-up Lost Time: Models the delay when a phase turns green, penalizing controllers that switch phases too frequently (e.g., standard MaxPressure).
2. Stochastic Demand: Replaces deterministic Poisson arrivals with stochastic Poisson sampling to prevent controllers from exploiting deterministic predictability.

Built-in Ecosystem

• Scenarios: 19 built-in scenarios, including synthetic grids/arterials and 16 real-world city networks imported from OpenStreetMap (e.g., Manhattan, Shanghai, London).
• Baselines: 7 pre-implemented controllers ranging from classical (FixedTime, Webster, SOTL, GreenWave) to adaptive (MaxPressure, LT-Aware MaxPressure).
• Visualization: A built-in web dashboard (FastAPI + WebSocket) for real-time simulation inspection and replay.

3. Key Contributions

1. Speed: A pure-Python CTM implementation achieving 800× to 21,000× real-time speedup compared to real-time, and 3–7× faster training than SUMO for RL tasks.
2. Standardization: Provides standard RL interfaces (Gymnasium/PettingZoo) with a pip install workflow, lowering the research barrier from days to minutes.
3. Fidelity Validation: Proven that LightSim's CTM dynamics exactly reproduce the theoretical triangular fundamental diagram ($R^2=1.0$).
4. Ranking Preservation: Demonstrated that LightSim preserves the relative performance rankings of both classical and RL controllers compared to SUMO across various network topologies.
5. Open Benchmark: Released as an open-source benchmark with full RL pipelines, baselines, and reproducible evaluation scripts.

4. Experimental Results

Experiments were conducted on a single CPU (Intel Core i7) across single intersections, arterial corridors, grid networks, and six real-world city networks.

• Speed Benchmarks:
  • LightSim processes 21,365 steps/s for a single intersection and 793 steps/s for a 64-intersection grid.
  • Training a PPO agent for 100k timesteps takes <5 minutes in LightSim vs. 15–30 minutes in SUMO (via TraCI).
• Fidelity & Ranking:
  • Physical Fidelity: Simulated density-flow relationships match the theoretical CTM curve perfectly.
  • Cross-Simulator Agreement: LightSim and SUMO agree on the relative ranking of controllers. For example, in both simulators, adaptive controllers (MaxPressure, SOTL) outperform FixedTime.
  • RL Transfer: Policies trained in LightSim (e.g., DQN) transfer effectively to SUMO, reducing average delay by 4.9× compared to FixedTime baselines.
• RL Performance:
  • DQN and PPO agents trained in LightSim consistently outperform rule-based baselines (FixedTime, MaxPressure) in terms of queue reduction and delay.
  • Reward Ablation: The "pressure" reward (upstream-downstream density difference) yielded better queue management than direct queue rewards.
  • Mesoscopic Impact: When lost time and stochasticity are enabled, standard MaxPressure performance collapses (due to frequent switching), while the proposed LT-Aware MaxPressure maintains high performance, matching SUMO rankings.
• Multi-Agent Coordination:
  • In a 4x4 grid, a shared-parameter DQN achieved 4.8× higher throughput than FixedTime.
  • A Decision Transformer (DT) trained via behavioral cloning on expert demonstrations outperformed all rule-based baselines, including GreenWave.

5. Significance and Limitations

Significance:

• Rapid Prototyping: LightSim enables researchers to iterate on RL algorithms and reward designs rapidly, confident that the best-performing algorithms will likely remain top performers in high-fidelity simulators.
• Reproducibility: By removing platform dependencies and complex configurations, it standardizes the evaluation of traffic signal control methods.
• Accessibility: Makes advanced traffic signal control research accessible to the broader RL community, not just transportation engineers.

Limitations:

• Macroscopic Nature: It does not model individual vehicle trajectories, lane-changing, or detailed geometric interactions. It is unsuitable for safety analysis (e.g., time-to-collision) or mixed-autonomy studies requiring vehicle-level metrics.
• Absolute Metrics: While relative rankings are preserved, absolute delay and queue values diverge significantly from SUMO due to the fundamental difference between aggregate density and individual vehicle tracking.
• Scalability: While fast for small-to-medium networks, the pure-Python implementation may face overhead at city-wide scales (thousands of intersections) compared to compiled C++ engines, though its simplicity remains an advantage.

Conclusion:
LightSim is not a replacement for microscopic simulators but a fast, ranking-preserving prototyping environment. It successfully lowers the barrier to entry for traffic signal control research, allowing for rigorous multi-seed RL experiments that were previously prohibitively slow.