---
title: 'SparseDriveV2: Scalable Score-Based Planning'
url: https://www.emergentmind.com/topics/sparsedrivev2
type: topic
---

# SparseDriveV2: Scalable Score-Based Planning

Searching arXiv for the specified paper and closely related planning methods to ground the article.
{"query":"SparseDriveV2 Scoring is All You Need for End-to-End Autonomous Driving arXiv 2603.29163", "max_results": 5}
{"query":"Hydra-MDP end-to-end autonomous driving arXiv", "max_results": 10}
SparseDriveV2 is an end-to-end autonomous driving planner organized around **scoring-based multimodal planning** rather than direct single-trajectory regression. The method enumerates many plausible candidate trajectories, assigns each a score, and selects the highest-scoring trajectory for control, treating multimodality as a first-class property of driving scenes such as intersections, merges, lane changes, and interactions around stopped vehicles. The central question posed by the work is whether strong end-to-end planning performance truly requires **dynamic proposal generation**, or whether a sufficiently dense **static vocabulary** can already cover the action space effectively if it is represented and scored in a scalable manner. SparseDriveV2 answers this question with a factorized trajectory vocabulary and a hierarchical scoring pipeline, and reports **92.0 PDMS** and **90.1 EPDMS** on NAVSIM, together with **89.15 Driving Score** and **70.00 Success Rate** on Bench2Drive using a lightweight ResNet-34 backbone [2603.29163].

## 1. Problem formulation and research context

End-to-end multi-modal planning commonly models uncertainty by scoring candidate trajectories and selecting the optimal one. Within this family, prior approaches are described as belonging to two broad groups. **Static-vocabulary methods** precompute a finite set of anchors, often by clustering trajectories from data; the paper lists VADv2, Hydra-MDP, Hydra-MDP++, and DriveSuprim as representative examples. These methods are simple and efficient at inference, but the vocabulary is typically only a few thousand trajectories, so the action space is discretized too coarsely. **Dynamic-proposal methods**, including regression-based, diffusion-based, or flow-based planners, can generate finer-grained candidates conditioned on the scene and often outperform static methods on benchmarks, but they introduce extra model components, iterative sampling or denoising, or more complex training [2603.29163].

The conceptual intervention of SparseDriveV2 is to revisit the assumption that dynamic generation is fundamentally necessary. The work argues that the apparent advantage of dynamic methods may stem less from generation itself than from better action-space coverage. This suggests that the central systems question is not simply whether trajectories are generated online, but whether the planner can maintain dense, scene-relevant coverage while preserving tractable scoring and inference.

SparseDriveV2 therefore remains within a **purely scoring-based** paradigm. Its two coupled design choices are a **factorized vocabulary representation** and a **scalable scoring strategy**. Together, these are intended to recover the coverage advantages usually associated with dynamic proposal generation without resorting to diffusion or iterative proposal synthesis [2603.29163].

## 2. Scaling evidence from Hydra-MDP

The paper’s first empirical contribution is a scaling study of Hydra-MDP, presented as a representative static-vocabulary scorer. The study increases the number of trajectory anchors and measures both performance and memory consumption. The reported trend is monotonic: as anchor count rises from **1024** to **16384**, **EPDMS on NAVSIM v2 increases from 85.02 to 87.35**, with consistent gains at every scale and no saturation before computational constraints become prohibitive [2603.29163].

| Anchor count | EPDMS on NAVSIM v2 | Memory |
|---|---:|---:|
| 1024 | 85.02 | 9.5 GB |
| 16384 | 87.35 | 38.9 GB |
| 32768 | out of memory | out of memory |

The significance of this scaling result is methodological. It supports the thesis that static vocabularies are not inherently weak; rather, naïve scaling of a monolithic static vocabulary is computationally expensive. A plausible implication is that prior performance gaps between static and dynamic planners may reflect representational and systems bottlenecks more than an intrinsic deficiency of scoring-based planning itself.

This scaling study directly motivates SparseDriveV2. If denser anchor sets continue to improve performance without saturation, then the critical problem becomes how to enlarge effective coverage without incurring the quadratic or memory-heavy costs associated with scoring a very large flat trajectory bank.

## 3. Factorized trajectory vocabulary

SparseDriveV2 addresses vocabulary scaling by factorizing a trajectory into two components: a **geometric path** and a **velocity profile**. A trajectory is defined as

$$
\tau = \{(x_t, y_t)\}_{t=1}^{T},
$$

with fixed temporal sampling. The factorization is written as

$$
p = \{(x_i, y_i)\}_{i=1}^{S}
$$

for the path, sampled at fixed spatial interval $\Delta s$, and

$$
v = \{v_t\}_{t=1}^{T}
$$

for the velocity profile, sampled at fixed temporal interval $\Delta t$ [2603.29163].

Extraction from a trajectory is expressed as

$$
(p, v) = \mathcal{D}(\tau),
$$

where the path is obtained by resampling the spatial shape of the trajectory along traveled distance, and the velocity is computed by

$$
v_t = \frac{\| (x_t, y_t) - (x_{t-1}, y_{t-1}) \|}{\Delta t}.
$$

Reconstruction is performed by composition,

$$
\tau = \mathcal{C}(p, v),
$$

with cumulative traveled distance

$$
s_t = \sum_{k=1}^{t} v_k \Delta t,
$$

and the position at each time recovered by interpolating along the path at distance $s_t$ [2603.29163].

The scalability gain comes from clustering paths and velocities separately:

$$
\mathcal{P}=\{p_i\}_{i=1}^{N_p}, \qquad \mathcal{V}=\{v_j\}_{j=1}^{N_v},
$$

and constructing the full trajectory vocabulary by Cartesian composition:

$$
\mathcal{T}=\{\tau_{i,j}\mid \tau_{i,j}=\mathcal{C}(p_i,v_j),\;p_i\in\mathcal{P},\;v_j\in\mathcal{V}\},
$$

so that

$$
|\mathcal{T}| = N_p \times N_v.
$$

In the main NAVSIM configuration, the model uses **1024 paths** and **256 velocities**, yielding **262,144 trajectories**, which the paper describes as **32× denser** than the common 8192-anchor static vocabularies used by prior methods [2603.29163].

The underlying structural claim is that many useful trajectories share geometry but differ in speed, or share a speed profile but differ in geometry. Factorization exploits this regularity rather than learning each full trajectory independently. This suggests a more general principle for end-to-end planning: decompositions that preserve semantically meaningful independence structure can substantially expand action-space coverage without proportionally increasing the size of the learned primitive set.

## 4. Hierarchical scoring architecture

A dense combinatorial vocabulary is only useful if it can be scored efficiently. SparseDriveV2 therefore uses a two-stage scoring pipeline consisting of **coarse factorized scoring** followed by **fine-grained scoring over composed trajectories** [2603.29163].

In the coarse stage, given scene features

$$
\mathbf{F}=\Phi(o_t), \qquad \mathbf{E}=\Psi(e_t),
$$

the model encodes each path anchor and velocity anchor into embeddings:

$$
\mathbf{e}^p_i = E_p(p_i), \qquad \mathbf{e}^v_j = E_v(v_j).
$$

Each path embedding is then contextually refined by path-scene interaction,

$$
\widetilde{\mathbf{e}^p_i} = \Psi_p(\mathbf{e}^p_i + \mathbf{E}, \mathbf{F}),
$$

and scored as

$$
s^p_i = f_p(\widetilde{\mathbf{e}^p_i}).
$$

Velocity profiles are processed analogously:

$$
\widetilde{\mathbf{e}^v_j} = \Psi_v(\mathbf{e}^v_j + \mathbf{E}, \mathbf{F}), \qquad s^v_j = f_v(\widetilde{\mathbf{e}^v_j}).
$$

For paths, the interaction may be implemented with **multi-head cross-attention** or **deformable aggregation along the path geometry**. Functionally, this stage acts as a fast filter that removes implausible components early, such as high-speed velocities in congestion or turning paths on a straight road [2603.29163].

After factorized scoring, the model retains only the top-$K_p$ paths and top-$K_v$ velocities, forming a reduced candidate set

$$
\mathcal{T}_{\text{coarse}} = \{\mathcal{C}(p_i,v_j)\mid p_i\in \mathcal{P}_{K_p},\; v_j\in \mathcal{V}_{K_v}\},
$$

whose size is $K_pK_v$, far smaller than the full Cartesian vocabulary.

The fine stage reintroduces joint reasoning at the composed-trajectory level. For each candidate $\tau_{i,j}$, the model fuses path and velocity representations as

$$
\mathbf{e}^{\tau}_{i,j} = \widetilde{\mathbf{e}^p_i} + \widetilde{\mathbf{e}^v_j},
$$

then applies trajectory-scene re-conditioning,

$$
\widetilde{\mathbf{e}^{\tau}_{i,j}} = \Psi_{\tau}(\mathbf{e}^{\tau}_{i,j}, \mathbf{F}),
$$

followed by final scoring,

$$
s^{\tau}_{i,j} = f_{\tau}(\widetilde{\mathbf{e}^{\tau}_{i,j}}).
$$

This second-stage re-conditioning is necessary because path and velocity are not truly independent. A sharp curve at high speed may be unsafe even when the path and velocity are individually plausible. The architecture therefore performs cheap factorized reasoning broadly and expensive joint spatiotemporal reasoning narrowly, which is the paper’s explicit solution to the scalability problem [2603.29163].

## 5. Training objective and inference

SparseDriveV2 is trained as a scoring model using soft targets derived from distances to expert behavior. For paths, the masked squared distance to the ground-truth geometric path $\hat p$ is

$$
d^p_i = \frac{1}{|\mathcal{M}|}\sum_{k\in\mathcal{M}}\|p_i(k)-\hat p(k)\|_2^2,
$$

and path scoring is supervised with

$$
\mathcal{L}_{\text{path}}=\mathrm{CE}\!\left(s^p,\;\mathrm{Softmax}(-\lambda_p d^p)\right).
$$

For velocity profiles,

$$
d^v_j = \sum_{t=1}^{T}|v_j(t)-\hat v(t)|,
$$

with loss

$$
\mathcal{L}_{\text{vel}}=\mathrm{CE}\!\left(s^v,\;\mathrm{Softmax}(-\lambda_v d^v)\right).
$$

For composed trajectories,

$$
d^\tau_k=\sum_{t=1}^{T}\|\tau_k(t)-\hat\tau(t)\|_2^2,
$$

and

$$
\mathcal{L}_{\text{traj}}=\mathrm{CE}\!\left(s^\tau,\;\mathrm{Softmax}(-\lambda_\tau d^\tau)\right).
$$

The model also uses metric supervision distilled from a rule-based teacher, with binary cross-entropy over sub-scores such as safety, progress, comfort, and rule compliance:

$$
\mathcal{L}_{\text{metric}}=\sum_m \mathrm{BCE}(s^{(m)},\hat s^{(m)}).
$$

The total objective is

$$
\mathcal{L}=\mathcal{L}_{\text{path}}+\mathcal{L}_{\text{vel}}+\mathcal{L}_{\text{traj}}+\alpha \mathcal{L}_{\text{metric}}.
$$

At inference time, the planner aggregates predicted sub-scores using the benchmark’s evaluation weighting and returns the trajectory with the highest final score [2603.29163].

This training design is notable because it combines imitation-oriented proximity supervision with metric-oriented teacher supervision. A plausible implication is that the model is not merely ranking trajectories by geometric similarity to expert data, but also learning benchmark-aligned notions of safety, comfort, progress, and rule compliance as explicit scoring dimensions.

## 6. Experimental protocol, results, and interpretation

The evaluation spans **NAVSIM** and **Bench2Drive**. NAVSIM v1 is described as an open-loop benchmark with metrics **NC, DAC, TTC, Comfort, and EP**, aggregated into **PDMS**. NAVSIM v2 extends the metric set to **NC, DAC, DDC, TL, EP, TTC, LK, HC, EC**, aggregated into **EPDMS**. Bench2Drive is a closed-loop CARLA benchmark with **Driving Score**, **Success Rate**, **Driving Efficiency**, and **Comfort**, together with multi-ability scores [2603.29163].

Implementation on NAVSIM uses a **ResNet-34** image backbone and selected front-camera images at **$256\times512$** resolution. The core vocabulary consists of **1024 path anchors** and **256 velocity anchors**. For efficient inference, the system first retains **top 128 paths** and **64 velocities**, then refines to **20 paths** and **20 velocities**, yielding **400 final trajectory hypotheses** for fine-grained scoring. On NAVSIM v2, the second-stage velocity count is reduced to **10** for faster metric computation. Training is performed on **8 L20 GPUs for 10 epochs** [2603.29163].

| Benchmark | Metric | Result |
|---|---|---:|
| NAVSIM v1 | PDMS | 92.0 |
| NAVSIM v2 | EPDMS | 90.1 |
| Bench2Drive | Driving Score | 89.15 |
| Bench2Drive | Success Rate | 70.00 |
| Bench2Drive | Multi-ability score | 67.67 |

The paper states that **92.0 PDMS** on NAVSIM v1 is the best reported result in its comparison table, outperforming all listed scoring-based and dynamic-generation baselines. On NAVSIM v2, SparseDriveV2 reaches **90.1 EPDMS** under the corrected official evaluation, surpassing DiffusionDriveV2 by **2.6 points** and outperforming strong scoring-based baselines with larger backbones. On Bench2Drive, it reports **89.15 Driving Score** and **70.00% Success Rate**, with a **67.67** multi-ability score, again presented as a new high among the compared methods [2603.29163].

The ablation studies are aligned with the paper’s two main claims. First, increasing $N_p$ and $N_v$ improves EPDMS monotonically; for example, moving from **512×128** to **1024×256** improves EPDMS from **88.7** to **90.1**. Second, **deformable aggregation** performs better than plain cross-attention in the path-scene interaction stage. Third, adding **trajectory re-conditioning** consistently improves results for both interaction types, indicating that independent path and velocity scoring is insufficient without a final joint compatibility model [2603.29163].

The broader interpretation offered by the work is that **scoring-based planning is not fundamentally limited by static vocabularies**. If the vocabulary is represented factorwise and scored hierarchically, a purely scoring-based planner can match or exceed the performance of more complex dynamic-generation approaches. The stated limitation is that the model can still fail when **navigation information is insufficient**, leading to incorrect high-level route decisions in some scenarios. More generally, the framework remains dependent on the quality of the factorized vocabulary and on the teacher or metric supervision used for scoring. Even with those caveats, the reported evidence supports a clear thesis: in end-to-end autonomous driving, **better coverage plus better scoring** may close much of the gap to dynamic proposal generation while preserving a simpler and more interpretable planning pipeline [2603.29163].

Source: https://www.emergentmind.com/topics/sparsedrivev2