Pith. sign in

REVIEW 3 major objections 5 minor 1 cited by

Vec-QMDP shows that POMDP belief-tree planning for self-driving runs in about 9 milliseconds on a CPU alone.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-03 03:18 UTC pith:USMBXFE3

load-bearing objection Good engineering, overstated speedup: the 1000x claim is throughput against a different algorithm; the honest end-to-end gain is ~10x. the 3 major comments →

arxiv 2602.08334 v2 pith:USMBXFE3 submitted 2026-02-09 cs.RO

Vec-QMDP: Vectorized POMDP Planning on CPUs for Real-Time Autonomous Driving

Xuanjin Jin , Yanxin Dong , Bin Sun , Huan Xu , Zhihui Hao , XianPeng Lang , Panpan Cai This is my paper
classification cs.RO
keywords POMDPQMDPSIMD vectorizationdata-oriented designautonomous drivingbelief tree searchparallel planningnuPlan
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

This paper tries to establish that CPU-only parallelization—multi-threading plus SIMD vectorization—can make POMDP planning practical for real-time autonomous driving. The authors build on the QMDP approximation, which splits the belief tree into independent scenario trees after the first action, so different futures can be searched in parallel. By refactoring data structures into cache-friendly, array-based layouts and batching both dynamics simulation and collision checking across SIMD lanes, they report 227×–1073× higher tree-construction throughput than a serial POMDP planner and end-to-end planning times of 9–14 ms on the nuPlan benchmark. If true, it would mean that uncertainty-aware planning can run on vehicle CPUs without GPU offload, and can match or beat learning-based planners without training data.

Core claim

The central claim is that the QMDP decomposition—usually regarded as a crude approximation—is exactly the structure needed to expose belief-tree search to modern CPU hardware. After the root action, each sampled scenario defines an independent sub-tree, so the search becomes a batch of parallel MDP-like searches. Vec-QMDP distributes sub-trees across CPU cores and SIMD lanes, vectorizes forward dynamics via global batching across scenarios, and vectorizes collision checks via local batching of agents within a node, with a load-balancing UCB to keep SIMD lanes at similar depths. The result is that a belief tree spanning over 10,000 future scenarios can be searched in roughly 9–14 ms, and the

What carries the argument

The QMDP approximation (uncertainty resolved after one step) turns one belief tree into K independent scenario trees, enabling lock-free parallel search. Data-Oriented Design replaces pointer-chasing trees with fixed-size arrays and Structure-of-Arrays storage, so SIMD can load node statistics, ego states, and agent boxes contiguously. Global vectorization batches transition dynamics across scenario trees; local vectorization batches multiple agents in a single node's collision check. A vectorized STR-tree (a spatial index of agent bounding boxes) prunes candidates in the broad phase, and a SIMD Separating-Axis-Theorem kernel handles narrow-phase contacts. The load-balancing UCB aligns expan

Load-bearing premise

The headline speedup compares tree-construction throughput against a serial planner that searches a different, hierarchical tree structure; if the baseline and metric are not matched, the 227×–1073× figure is not a clean parallel speedup.

What would settle it

Measure end-to-end planning latency for Vec-QMDP and a serial QMDP implementation that builds the same scenario trees, varying only threads and SIMD width; if the latency gap is far below 64× (8 threads × 8 SIMD lanes), most of the reported speedup comes from the QMDP reformulation rather than parallel execution.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • Belief-tree planning under uncertainty can fit within a 100 ms control cycle on CPU-only hardware, eliminating GPU host-device synchronization as a bottleneck.
  • The high tree-construction throughput lets the planner evaluate thousands of futures per cycle, enabling detection of rare, high-risk interactions such as aggressive cut-ins.
  • The Data-Oriented Design and two-mode vectorization could transfer to other robotics domains that use multi-scenario tree search.
  • Lock-free per-thread ownership of scenario trees gives near-linear scaling with core count, so search capacity grows directly with CPU resources.
  • Matching or beating learning-based planners without training data suggests uncertainty-aware search is a competitive alternative to imitation and diffusion planners.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The reported speedup is measured as tree-construction throughput against a serial hierarchical planner; end-to-end latency improves only about 7–10×, so the algorithmic reformulation (QMDP vs. hierarchical trees) may contribute more than raw parallelism to the headline number.
  • The QMDP assumption excludes active information gathering, so the planner is best suited to problems where the first action resolves most uncertainty; a hybrid that adds information-gathering only when needed is a natural next step.
  • The load-balancing UCB requires only expansion-depth ranges, so it could generalize to any parallel tree search with heterogeneous rollout costs, not just autonomous driving.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper proposes Vec-QMDP, a CPU-native parallel planner for autonomous driving under uncertainty. It applies the QMDP approximation to decompose a belief tree into K independent scenario trees, then parallelizes tree search with M CPU threads and N SIMD lanes. The implementation uses Data-Oriented Design (DOD), SoA memory layouts, vectorized STR-tree collision checking, and a load-balancing UCB to reduce SIMD depth divergence. The paper evaluates the planner on nuPlan and reports two main results: (i) driving scores comparable to or better than existing learning-based, model-based, and hybrid baselines with 9–14 ms planning time, and (ii) a 227×–1073× speedup in tree-construction throughput over the serial POMDP planner Hi-Drive.

Significance. If the efficiency claims hold, the paper would be an important demonstration that POMDP-style belief-tree search can run at real-time rates on commodity CPUs, without GPU synchronization overhead. The use of an external closed-loop benchmark (nuPlan), the explicit ablation of multi-threading and load balancing, and the detailed description of vectorized data layouts are strengths. However, the central speedup claim is currently difficult to interpret because it is based on a throughput metric measured against a hierarchically different planner, and the reported ratios exceed the theoretical parallel budget of the machine by a large factor. The driving-score results are plausible but would benefit from statistical rigor.

major comments (3)
  1. [Abstract; §VII.B–D] The headline '227×–1073× speedup' is tree-construction throughput (edges/ms) relative to Hi-Drive, not an end-to-end speedup. Table I shows planning time 92 ms → 9–14 ms, roughly 7–10×. With M=8 threads and SIMD width N=8, the hardware parallel budget is 64×; even with the ~1.24× load-balancing gain reported in §VII.F, the upper bound under optimistic assumptions is ~80×. The remaining factor (up to ~13×) must come from algorithmic differences—QMDP's independent scenario trees vs Hi-Drive's hierarchical POMDP tree—and DOD memory layout. No serial QMDP baseline is provided, so the claim that parallelization alone yields the reported ratio is unsupported. Please report end-to-end speedups and decompose contributions (serial QMDP, DOD, SIMD, multi-threading, load balancing).
  2. [§VII.B; §III; §V-A] The throughput metric counts H−d edges for every expanded node at depth d, so the definition of an 'edge' depends on the action hierarchy. Hi-Drive is a hierarchical POMDP planner whose abstract actions have different granularity, while Vec-QMDP uses 9 fixed 2 s macro-actions. Comparing edges/ms across these two very different tree constructions conflates algorithmic restructuring with computational speed. The 227×–1073× ratio has no clear causal interpretation as a parallelization gain unless the baseline builds the same QMDP scenario trees under the same edge definition. The paper should either provide a matched serial baseline or present a metric that counts comparable search work (e.g., simulated scenario-steps).
  3. [Table I; §VII.C] The driving-score superiority claim rests on small margins (e.g., Val14 R: 93.15 vs. 93.15; Test14-random R: 92.51 vs. 92.31; Test14-hard R: 84.23 vs. 83.18). Baselines are reported without variance or per-scene error bars, while the new method's CIs are based on repeated runs. For a closed-loop benchmark with scene-level noise, such differences may not be significant. Please report paired per-scene statistics or at least standard errors for all planners, and clarify how many independent runs produced the ± values. This does not affect the efficiency critique but is needed to support the 'state-of-the-art planning performance' claim.
minor comments (5)
  1. [Abstract] The phrase '227×–1073× speedup over state-of-the-art serial planners' should be qualified as 'tree-construction throughput speedup' to avoid the impression of an end-to-end planning-time speedup.
  2. [§V-C] The symbol N is used both for the SIMD width and for the number of nodes in a batch ('Given the selected expanded node indices {v_i}_{i=1}^N'), which is confusing. Use a distinct symbol for the batch size.
  3. [§V-E] The load-balancing UCB score depends on a weight λ, but no value or sensitivity analysis is reported. Please state the chosen λ and, ideally, show that the results are not overly sensitive to it.
  4. [§VIII] The limitations paragraph is commendable. Consider also noting in the abstract/conclusion that the method targets tasks where active information gathering is not required, since the QMDP approximation assumes uncertainty resolves after the first action.
  5. [Fig. 4] The speedup plot would benefit from a log-scale y-axis or explicit annotation of the 64× hardware parallel budget, so readers can immediately see the gap between parallelization limits and the reported ratio.

Circularity Check

0 steps flagged

No circularity: empirical speedup and nuPlan scores are measured externally; QMDP decomposition is cited from external prior work and the self-cited Hi-Drive baseline is used as a measured comparator, not as a proof input.

full rationale

Vec-QMDP's central claims are computational (227x-1073x throughput vs Hi-Drive, 9-14 ms planning) and empirical (nuPlan driving scores in Table I). These are not derived from the claims themselves: Fig. 4/5/6 and Table I report measurements against external baselines and ablations. The QMDP value approximation in Eq. (1) is a standard decomposition cited to Littman et al. [21], external to the authors; the vectorized tree search and trajectory optimization are algorithm engineering contributions whose behavior is then benchmarked, not predicted from fitted parameters. The only notable self-citation is the serial baseline Hi-Drive [17], by overlapping authors, but the comparison is a measured runtime/throughput comparison on nuPlan, and the paper does not invoke Hi-Drive as a theorem or as justification for correctness. A metric-comparability concern (edges/ms may conflate QMDP's tree restructuring with parallel speedup, and end-to-end time gain is smaller) is a validity/correctness issue about what the speedup measures, not circularity: no quantity is defined in terms of the result, no fitted parameter is renamed as a prediction, and no load-bearing claim reduces to the authors' prior work by construction. The stated limitations (QMDP assumes uncertainty resolves after first action; SIMD efficiency depends on uniformity) further make assumptions explicit rather than hiding them. Thus no circular step can be exhibited under the required standard.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 0 invented entities

The central claims rest on the QMDP independence decomposition, on the correctness of the simulator/reward model, and on hardware assumptions about SIMD and memory layout. No new physical or mathematical entities are introduced.

free parameters (4)
  • Load-balancing UCB weight λ = not reported
    Introduced in §V-E; controls depth-alignment biasing. Value needed to reproduce Fig. 6; likely tuned on the nuPlan workloads.
  • Scenario count K per planning cycle = not reported
    QMDP value in Eq. (1) averages over K scenarios; Fig. 1 mentions 10,000+ scenarios but no exact K per cycle. Affects speedup and driving score.
  • Planning time budgets = 9 ms / 14 ms
    Selected to report 'match' and 'best' performance; an evaluation choice that shapes the headline claims rather than a model parameter.
  • Macro-action set design = |A|=9, Δt=2s, T=8s
    Hand-chosen action branching and horizon, inherited from Hi-Drive; determines tree size and depth.
axioms (5)
  • domain assumption QMDP approximation: after the first action, uncertainty is resolved; value is the average of deterministic MDP values.
    Eq. (1); enables independent scenario sub-trees. Acknowledged in the conclusion to limit active information gathering.
  • domain assumption Exogenous agents follow fixed sampled trajectories ξ; transition is deterministic given (s, a, ξ).
    Sec. IV-A/B; basis for independent scenario trees and for building the STR-tree once at the root.
  • domain assumption IDM/Stanley/MOBIL forward simulation accurately models interactive traffic dynamics.
    Sec. V-A; used in rollout and trajectory optimization to generate and evaluate trajectories.
  • domain assumption Self-normalized importance sampling with proposal q is unbiased; q must cover the true belief support.
    Sec. VI-A; if q shifts mass only to map-based critical agents and misses other hazards, trajectory evaluation may be biased.
  • domain assumption SIMD vectorization assumes sufficiently uniform compute cost across scenario trees.
    Sec. V-C and conclusion: the authors state that highly heterogeneous transition dynamics may still underutilize SIMD lanes.

pith-pipeline@v1.3.0-alltime-deepseek · 10904 in / 14267 out tokens · 160608 ms · 2026-08-03T03:18:48.749012+00:00 · methodology

0 comments
read the original abstract

Planning under uncertainty for real-world robotics tasks, such as autonomous driving, requires reasoning in enormous high-dimensional belief spaces, rendering the problem computationally intensive. While parallelization offers scalability, existing hybrid CPU-GPU solvers face critical bottlenecks due to host-device synchronization latency and branch divergence on SIMT architectures, limiting their utility for real-time planning and hindering real-robot deployment. We present Vec-QMDP, a CPU-native parallel planner that aligns POMDP search with modern CPUs' SIMD architecture, achieving $227\times$--$1073\times$ speedup over state-of-the-art serial planners. Vec-QMDP adopts a Data-Oriented Design (DOD), refactoring scattered, pointer-based data structures into contiguous, cache-efficient memory layouts. We further introduce a hierarchical parallelism scheme: distributing sub-trees across independent CPU cores and SIMD lanes, enabling fully vectorized tree expansion and collision checking. Efficiency is maximized with the help of UCB load balancing across trees and a vectorized STR-tree for coarse-level collision checking. Evaluated on large-scale autonomous driving benchmarks, Vec-QMDP achieves state-of-the-art planning performance with millisecond-level latency, establishing CPUs as a high-performance computing platform for large-scale planning under uncertainty.

Figures

Figures reproduced from arXiv: 2602.08334 by Bin Sun, Huan Xu, Panpan Cai, Xianpeng Lang, Xuanjin Jin, Yanxin Dong, Zhihui Hao.

Figure 1
Figure 1. Figure 1: Real-time belief tree search in complex urban environ [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Overview of Vec-QMDP. (a) Sample the belief into M × N scenarios in an SoA layout. (b) Vectorized QMDP search: after the first action, scenario trees run in parallel on M CPU threads; within each thread, SIMD global vectorization batches transition dynamics across scenarios and SIMD local vectorization accelerates within-node collision checks. (c) Vectorized trajectory optimization: generate candidates and… view at source ↗
Figure 3
Figure 3. Figure 3: Two-stage SIMD collision checking. (a) Broad phase: SIMD AABB tests in the Frenet frame traverse a pointer-less STR-tree to prune candidates. (b) Narrow phase: SIMD SAT checks evaluate ego– agent pairs to compute collisions. updates with masked execution, and writes back the updated ego states to the corresponding node buffers. The control flow remains largely uniform due to the macro-action design, with d… view at source ↗
Figure 4
Figure 4. Figure 4: Tree construction throughput. (Left) Edges/ms vs. traffic density. (Right) Speedup over serial Hi-Drive (227×–1073×), in￾creasing with density. results demonstrate that our planner can either minimize com￾putational overhead for matching performance or maximize driving quality under standard real-time constraints. Performance gains are most significant in Test14-hard scenes. In these challenging environmen… view at source ↗
Figure 5
Figure 5. Figure 5: Ablation: multi-threading. (Left) Edges/ms vs. traffic den￾sity. (Right) Speedup over single-threaded (ST), showing near-linear scaling (∼8×). (a) Throughput (edges/ms) (b) Speedup (LB vs. w/o LB) [PITH_FULL_IMAGE:figures/full_fig_p008_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Ablation: load-balancing UCB. (Left) Edges/ms vs. load imbalance. (Right) Speedup over w/o LB, up to 1.24× in highly imbalanced scenes. cores) with a single-threaded variant (ST). Both use identical SIMD-vectorized kernels and Data-Oriented Design (DOD) [PITH_FULL_IMAGE:figures/full_fig_p008_6.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. Hypothesis-driven Model Expansion under Uncertainty for Open-World Robot Planning

    cs.RO 2026-07 conditional novelty 6.5

    HUME lets robots generate, plan over, and actively verify object-centric hypotheses from foundation models so incomplete symbolic models become usable for open-world household tasks.

Reference graph

Works this paper leans on

29 extracted references · 4 linked inside Pith · cited by 1 Pith paper

  1. [1]

    Finite-time analysis of the multiarmed bandit problem

    Peter Auer, Nicolo Cesa-Bianchi, and Paul Fischer. Finite-time analysis of the multiarmed bandit problem. Machine learning, 47(2):235–256, 2002

    2002

  2. [2]

    Parallelizing pomcp to solve complex pomdps

    Semanti Basu, Sreshtaa Rajesh, Kaiyu Zheng, Stefanie Tellex, and R Iris Bahar. Parallelizing pomcp to solve complex pomdps. InRss workshop on software tools for real-time optimal control, 2021

    2021

  3. [3]

    nuplan: A closed-loop ml-based planning benchmark for autonomous vehicles

    Holger Caesar, Juraj Kabzan, Kok Seang Tan, Whye Kit Fong, Eric Wolff, Alex Lang, Luke Fletcher, Oscar Beijbom, and Sammy Omari. nuplan: A closed-loop ml-based planning benchmark for autonomous vehicles. arXiv preprint arXiv:2106.11810, 2021

    Pith/arXiv arXiv 2021

  4. [4]

    Collision detection using axis aligned bounding boxes

    Panpan Cai, Chandrasekaran Indhumathi, Yiyu Cai, Jian- min Zheng, Yi Gong, Teng Sam Lim, and Peng Wong. Collision detection using axis aligned bounding boxes. InSimulations, Serious Games and Their Applications, pages 1–14. Springer, 2013

    2013

  5. [5]

    Hyp-despot: A hybrid parallel algorithm for online planning under uncertainty.The International Journal of Robotics Research, 40(2-3):558–573, 2021

    Panpan Cai, Yuanfu Luo, David Hsu, and Wee Sun Lee. Hyp-despot: A hybrid parallel algorithm for online planning under uncertainty.The International Journal of Robotics Research, 40(2-3):558–573, 2021

    2021

  6. [6]

    On the paral- lelization of uct

    Tristan Cazenave and Nicolas Jouandeau. On the paral- lelization of uct. InComputer games workshop, 2007

    2007

  7. [7]

    Parallel monte-carlo tree search

    Guillaume MJ-B Chaslot, Mark HM Winands, and H Jaap van Den Herik. Parallel monte-carlo tree search. InInternational Conference on Computers and Games, pages 60–71. Springer, 2008

    2008

  8. [8]

    PLUTO: Pushing the Limit of Imitation Learning-based Planning for Autonomous Driving, April 2024

    Jie Cheng, Yingbing Chen, and Qifeng Chen. PLUTO: Pushing the Limit of Imitation Learning-based Planning for Autonomous Driving, April 2024. arXiv:2404.14327

    Pith/arXiv arXiv 2024

  9. [9]

    Rethinking imitation-based plan- ners for autonomous driving

    Jie Cheng, Yingbing Chen, Xiaodong Mei, Bowen Yang, Bo Li, and Ming Liu. Rethinking imitation-based plan- ners for autonomous driving. In2024 IEEE International Conference on Robotics and Automation, pages 14123– 14130. IEEE, 2024

    2024

  10. [10]

    Object oriented programming

    Brad J Cox. Object oriented programming. 1984

    1984

  11. [11]

    Parting with misconceptions about learning-based vehicle motion planning

    Daniel Dauner, Marcel Hallgarten, Andreas Geiger, and Kashyap Chitta. Parting with misconceptions about learning-based vehicle motion planning. InConference on Robot Learning, pages 1268–1281. PMLR, 2023

    2023

  12. [12]

    Data-oriented design.Richard Fabian, 2013

    Richard Fabian. Data-oriented design.Richard Fabian, 2013

    2013

  13. [13]

    Reducing branch divergence in gpu programs

    Tianyi David Han and Tarek S Abdelrahman. Reducing branch divergence in gpu programs. InProceedings of the fourth workshop on general purpose processing on graphics processing units, pages 1–8, 2011

    2011

  14. [14]

    Stanford University, 1988

    Timothy Classen Hesterberg.Advances in importance sampling. Stanford University, 1988

    1988

  15. [15]

    Vectorized online pomdp planning.arXiv preprint arXiv:2510.27191, 2025

    Marcus Hoerger, Muhammad Sudrajat, and Hanna Kurni- awati. Vectorized online pomdp planning.arXiv preprint arXiv:2510.27191, 2025

    Pith/arXiv arXiv 2025

  16. [16]

    Separating axis theorem for oriented bounding boxes

    Johnny Huynh. Separating axis theorem for oriented bounding boxes. pages 3–45, 2009. URL https://jkh.me/ files/tutorials/Separating%20Axis%20Theorem%20for% 20Oriented%20Bounding%20Boxes.pdf

    2009

  17. [17]

    Hi-drive: Hierarchical pomdp planning for safe autonomous driving in diverse urban environments.IEEE Robotics and Automation Letters, 2025

    Xuanjin Jin, Chendong Zeng, Shengfa Zhu, Chunxiao Liu, and Panpan Cai. Hi-drive: Hierarchical pomdp planning for safe autonomous driving in diverse urban environments.IEEE Robotics and Automation Letters, 2025

    2025

  18. [18]

    General lane-changing model mobil for car-following models

    Arne Kesting, Martin Treiber, and Dirk Helbing. General lane-changing model mobil for car-following models. Transportation Research Record, 1999(1):86–94, 2007

    1999

  19. [19]

    Parallelization of monte carlo tree search in continuous domains.arXiv preprint arXiv:2003.13741, 2020

    Karl Kurzer, Christoph H ¨ortnagl, and J Marius Z ¨ollner. Parallelization of monte carlo tree search in continuous domains.arXiv preprint arXiv:2003.13741, 2020

    Pith/arXiv arXiv 2003

  20. [20]

    Str: A simple and efficient algorithm for r-tree packing

    Scott T Leutenegger, Mario A Lopez, and Jeffrey Edg- ington. Str: A simple and efficient algorithm for r-tree packing. InProceedings 13th international conference on data engineering, pages 497–506. IEEE, 1997

    1997

  21. [21]

    Learning policies for partially ob- servable environments: Scaling up

    Michael L Littman, Anthony R Cassandra, and Leslie Pack Kaelbling. Learning policies for partially ob- servable environments: Scaling up. InMachine Learning Proceedings 1995, pages 362–370. Elsevier, 1995

    1995

  22. [22]

    Importance sampling for online planning under uncer- tainty.The International Journal of Robotics Research, 38(2-3):162–181, 2019

    Yuanfu Luo, Haoyu Bai, David Hsu, and Wee Sun Lee. Importance sampling for online planning under uncer- tainty.The International Journal of Robotics Research, 38(2-3):162–181, 2019

    2019

  23. [23]

    Despot: Online pomdp planning with regularization

    Adhiraj Somani, Nan Ye, David Hsu, and Wee Sun Lee. Despot: Online pomdp planning with regularization. Advances in neural information processing systems, 26, 2013

    2013

  24. [24]

    Abstraction for aos and soa layout in c++

    Robert Strzodka. Abstraction for aos and soa layout in c++. InGPU computing gems Jade edition, pages 429–

  25. [25]

    Motions in microseconds via vectorized sampling-based planning

    Wil Thomason, Zachary Kingston, and Lydia E Kavraki. Motions in microseconds via vectorized sampling-based planning. In2024 IEEE International Conference on Robotics and Automation (ICRA), pages 8749–8756. IEEE, 2024

    2024

  26. [26]

    Stanley: The robot that won the darpa grand challenge

    Sebastian Thrun, Mike Montemerlo, Hendrik Dahlkamp, David Stavens, Andrei Aron, James Diebel, Philip Fong, John Gale, Morgan Halpenny, Gabriel Hoffmann, et al. Stanley: The robot that won the darpa grand challenge. Journal of field Robotics, 23(9):661–692, 2006

    2006

  27. [27]

    Congested traffic states in empirical observations and microscopic simulations.Physical review E, 62(2):1805, 2000

    Martin Treiber, Ansgar Hennecke, and Dirk Helbing. Congested traffic states in empirical observations and microscopic simulations.Physical review E, 62(2):1805, 2000

    2000

  28. [28]

    Diffusion-based planning for autonomous driving with flexible guidance

    Yinan Zheng, Ruiming Liang, Kexin ZHENG, Jinliang Zheng, Liyuan Mao, Jianxiong Li, Weihao Gu, Rui Ai, Shengbo Eben Li, Xianyuan Zhan, and Jingjing Liu. Diffusion-based planning for autonomous driving with flexible guidance. InThe Thirteenth International Conference on Learning Representations, 2025

    2025

  29. [29]

    Query-centric trajectory prediction

    Zikang Zhou, Jianping Wang, Yung-Hui Li, and Yu-Kai Huang. Query-centric trajectory prediction. InProceed- ings of the IEEE/CVF conference on computer vision and pattern recognition, pages 17863–17873, 2023

    2023