Paper deep dive
SDPAD: A Fully Spike-Driven Pipeline for End-to-End Autonomous Driving
Chengjun Zhang, Yuhao Zhang, Jie Yang, Mohamad Sawan
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 10/10/2026, 1:57:58 AM
Summary
The paper introduces SDPAD, a fully spike-driven end-to-end autonomous driving pipeline that replaces dense artificial neural network (ANN) computations with spiking neural networks (SNNs) to achieve significant energy efficiency while maintaining planning accuracy. SDPAD utilizes a quantized ANN2SNN conversion, a novel Spike-3D-Lift mechanism for bird's-eye-view (BEV) representation using spike-driven-max, and a Spike-QFormer for waypoint decoding via spiking cross-attention. It achieves competitive performance on nuScenes and NAVSIM benchmarks with less than 2% of the energy consumption of state-of-the-art ANN baselines.
Entities (10)
Relation Signals (8)
SDPAD → evaluatedon → nuScenes
confidence 95% · On the nuScenes open-loop benchmark, SDPAD achieves an average L2 error of 0.40 m
SDPAD → evaluatedon → NAVSIM
confidence 95% · In closed-loop evaluation on the NAVSIM navtest split, SDPAD reaches 86.3 PDMS
SDPAD → istypeof → Spiking Neural Network
confidence 95% · SDPAD, a fully spike-driven end-to-end planning pipeline
SDPAD → uses → Spike-3D-Lift
confidence 95% · SDPAD ... lifts multi-view images into the bird’s-eye-view (BEV) space with a spike-driven-max (SDM) depth distribution (Spike-3D-Lift)
SDPAD → uses → Spike-QFormer
confidence 95% · plans through the Spike-QFormer, a spiking query transformer
SDPAD → outperforms → SAD
confidence 90% · surpassing the previous SNN planner SAD by 4.3 points
SDPAD → replaces → Artificial Neural Network
confidence 90% · systematically replacing dense computation with spike-driven operations throughout the entire pipeline
Spike-QFormer → uses → Deformable Spike-Cross-Attention
confidence 90% · followed by deformable spike-cross-attention refinement
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:End-to-end autonomous driving demands trajectory planners that are both highly accurate and cheap enough for edge deployment. State-of-the-art artificial neural network (ANN) planners meet the accuracy requirement at the cost of heavy dense computation, while spiking neural networks (SNNs)---though promising orders-of-magnitude energy savings through sparse, event-driven arithmetic---still lag far behind in planning accuracy. We present \textbf{SDPAD}, a fully spike-driven end-to-end planning pipeline that closes this gap. SDPAD converts a pre-trained ANN perception stack into integer-spike form via quantized ANN2SNN conversion, lifts multi-view images into the bird's-eye-view (BEV) space with a spike-driven-max (SDM) depth distribution (Spike-3D-Lift), and plans through the Spike-QFormer, a spiking query transformer in which ego, agent, and map queries distilled from the BEV scene are fused by learnable waypoint queries via cross-attention, followed by deformable spike-cross-attention refinement. Every operation is gated by integer spikes and inference is a single feed-forward pass without temporal simulation loops. On the nuScenes open-loop benchmark, SDPAD achieves an average $L_2$ error of 0.40\,m and a collision rate of 0.12\%, on par with strong ANN planners while consuming 69.9\,mJ---less than 2\% of recent ANN baselines. In closed-loop evaluation on the NAVSIM navtest split, SDPAD reaches 86.3 PDMS, surpassing the previous SNN planner SAD by 4.3 points and matching mainstream ANN planners at a fraction of their energy. To our knowledge, SDPAD is the first fully spike-driven planner evaluated in end-to-end autonomous driving, demonstrating that SNNs can rival dense ANNs in complex driving tasks.
Tags
Links
- Source: https://arxiv.org/abs/2610.11583v1
- Canonical: https://arxiv.org/abs/2610.11583v1
Trouble viewing inline? Open PDF directly →
Full Text
57,265 characters extracted from source content.
Expand or collapse full text
SDPAD: A Fully Spike-Driven Pipeline for End-to-End Autonomous Driving Chengjun Zhang Affiliation: Zhejiang Key Laboratory of 3D Micro/Nano Fabrication and CharacterizationWestlake Institute for Optoelectronics, Fuyang, Hangzhou, China Affiliation: Integrated-On-Chips Brain-Computer Interfaces Zhejiang Engineering Research CenterHangzhou, Zhejiang, China Yuhao Zhang Affiliation: Zhejiang Key Laboratory of 3D Micro/Nano Fabrication and CharacterizationWestlake Institute for Optoelectronics, Fuyang, Hangzhou, China Affiliation: Integrated-On-Chips Brain-Computer Interfaces Zhejiang Engineering Research CenterHangzhou, Zhejiang, China Jie Yang Affiliation: Zhejiang Key Laboratory of 3D Micro/Nano Fabrication and CharacterizationWestlake Institute for Optoelectronics, Fuyang, Hangzhou, China Affiliation: Integrated-On-Chips Brain-Computer Interfaces Zhejiang Engineering Research CenterHangzhou, Zhejiang, China Affiliation: CenBRAIN Neurotech, School of Engineering, Westlake UniversityHangzhou, Zhejiang, ChinaCorresponding authors: Jie Yang and Mohamad Sawanyangjie@westlake.edu.cn; sawan@westlake.edu.cn Mohamad Sawan Affiliation: Zhejiang Key Laboratory of 3D Micro/Nano Fabrication and CharacterizationWestlake Institute for Optoelectronics, Fuyang, Hangzhou, China Affiliation: Integrated-On-Chips Brain-Computer Interfaces Zhejiang Engineering Research CenterHangzhou, Zhejiang, China Affiliation: CenBRAIN Neurotech, School of Engineering, Westlake UniversityHangzhou, Zhejiang, ChinaCorresponding authors: Jie Yang and Mohamad Sawanyangjie@westlake.edu.cn; sawan@westlake.edu.cn Abstract End-to-end autonomous driving demands trajectory planners that are both highly accurate and cheap enough for edge deployment. State-of-the-art artificial neural network (ANN) planners meet the accuracy requirement at the cost of heavy dense computation, while spiking neural networks (SNNs)—though promising orders-of-magnitude energy savings through sparse, event-driven arithmetic—still lag far behind in planning accuracy. We present SDPAD, a fully spike-driven end-to-end planning pipeline that closes this gap. SDPAD converts a pre-trained ANN perception stack into integer-spike form via quantized ANN2SNN conversion, lifts multi-view images into the bird’s-eye-view (BEV) space with a spike-driven-max (SDM) depth distribution (Spike-3D-Lift), and plans through the Spike-QFormer, a spiking query transformer in which ego, agent, and map queries distilled from the BEV scene are fused by learnable waypoint queries via cross-attention, followed by deformable spike-cross-attention refinement. Every operation is gated by integer spikes and inference is a single feed-forward pass without temporal simulation loops. On the nuScenes open-loop benchmark, SDPAD achieves an average L2L_2 error of 0.40 m and a collision rate of 0.12%, on par with strong ANN planners while consuming 69.9 mJ—less than 2% of recent ANN baselines. In closed-loop evaluation on the NAVSIM navtest split, SDPAD reaches 86.3 PDMS, surpassing the previous SNN planner SAD by 4.3 points and matching mainstream ANN planners at a fraction of their energy. To our knowledge, SDPAD is the first fully spike-driven planner evaluated in end-to-end autonomous driving, demonstrating that SNNs can rival dense ANNs in complex driving tasks. 1 Introduction The evolution of end-to-end autonomous driving has seen a paradigm shift from modular pipelines to unified neural architectures capable of directly mapping raw sensor data to control signals Chen et al. (2024a). While these dense artificial neural network (ANN) models, as shown in Fig. 1a—ranging from vectorized scene planners such as ST-P3, UniAD and VAD Hu et al. (2022); Hu et al. (2023); Jiang et al. (2023) to recent world-model and diffusion-based planners Li et al. (2025); Yang et al. (2025b); Zheng et al. (2025); Liao et al. (2025); Zhang et al. (2026b)—exhibit impressive closed-loop and open-loop performance, they are constrained by a fundamental performance–efficiency dilemma. The stringent latency and power envelopes of embedded vehicular hardware make the deployment of heavy transformer-based or dense convolutional backbones highly challenging, even when adopting lightweight variants. Figure 1: The comparison of different end-to-end paradigms. (a) Dense ANN pipelines compute in floating point throughout. (b) Existing SNN planners still rely on continuous membrane potentials or softmax depth scores for BEV lifting. (c) SDPAD is fully spike-driven end to end: the proposed Spike-3D-Lift turn BEV sampling into spike BEV representation. Spiking neural networks (SNNs) present a theoretically ideal solution for embedded agents Martínez et al. (2024); Yang et al. (2025a). By mimicking biological neurons, SNNs execute event-driven, sparse computing through discrete spikes, achieving high energy efficiency on neuromorphic hardware by leveraging spatial and temporal sparsity Zhu et al. (2024) (Fig. 1b). However, despite their success in low-dimensional control and basic perception, SNNs still lack a planning-grade architecture for autonomous driving. We identify three concrete bottlenecks. First, mainstream SNN-based driving models rely on iterative time-steps simulations, where sequential state updates introduce substantial latency overhead and hinder real-time deployment. Second, energy-efficient 2D-to-3D feature lifting, a prerequisite for BEV perception, depends on dense, floating-point softmax depth distributions that are ill-suited to spike-driven hardware. Third, existing spiking planners cannot model the multimodal interactions among the ego vehicle, surrounding agents, and map context, because their decoders lack a query-based mechanism to selectively aggregate heterogeneous scene information. To address these bottlenecks, we introduce SDPAD, as shown in Fig. 1c, a fully spike-driven pipeline for end-to-end autonomous driving. SDPAD leverages fully integer-valued, rate-coded spike computations within a single feed-forward pass, completely dispensing with temporal unrolling. Concretely, a pre-trained ANN perception stack is converted into integer-spike form through quantized ANN2SNN conversion, and multi-view images are lifted into the BEV space by the proposed Spike-3D-Lift, which replaces the softmax depth distribution with a spike-driven-max so that frustum construction degenerates into spike-gated accumulation. On top of the Spiking BEV representation, the proposed Spike-QFormer distills three complementary query groups, an ego query, agent queries, and map queries, through spiking decoder layers, and lets learnable waypoint queries fuse them via a single-layer spiking cross-attention, producing command-conditioned trajectory candidates that are further refined by a deformable spike-cross-attention module anchored to the predicted trajectory itself. Auxiliary BEV segmentation and agent-state supervision regularize the scene representation during training. The core contributions of this work are three-fold: 1. We propose SDPAD, to our knowledge the first fully spike-driven end-to-end planner evaluated in closed loop on NAVSIM. Built on integer-spike computation with single-pass inference, it avoids the latency of temporal simulation loops entirely. 2. We propose Spike-3D-Lift, which replaces the floating-point softmax depth distribution with a spike-driven-max, turning 2D-to-3D BEV lifting into hardware-friendly spike-gated accumulation while preserving geometric fidelity. 3. We propose the Spike-QFormer, a unified spiking query transformer that distills ego, agent, and map context into dedicated query groups and fuses them into waypoint predictions via spiking cross-attention, together with a deformable spike-cross-attention module for trajectory refinement. Extensive experiments on nuScenes and NAVSIM show that SDPAD substantially narrows the gap between SNN and ANN planners, achieving planning accuracy comparable to mainstream ANN baselines at a small fraction of their energy consumption. 2 Related Work 2.1 End-to-End Autonomous Driving Recent end-to-end models integrate perception, prediction, and planning into a differentiable framework. Methods like UniAD and VAD Hu et al. (2023); Jiang et al. (2023) utilize vectorized representations and bird’s-eye-view (BEV) spaces to explicitly model scene geometry and agent interactions. Subsequent works further improve planning quality through probabilistic anchor vocabularies Chen et al. (2024b), sparse scene representations Sun et al. (2025), truncated diffusion sampling Liao et al. (2025), and latent world models Li et al. (2025); Zheng et al. (2025); Zhang et al. (2026b). While these models represent the state of the art in Planning Decision Metric Score (PDMS) on simulators like NAVSIM Dauner et al. (2024), their reliance on heavy dense decoder stacks results in immense multiply–accumulate (MAC) counts, creating a bottleneck for real-time edge deployment. SDPAD matches state-of-the-art planning performance while systematically replacing dense computation with spike-driven operations throughout the entire pipeline. 2.2 Spiking Neural Networks SNNs have achieved competitive accuracy in image classification and object detection through both ANN-to-SNN conversion Ding et al. (2021) and direct surrogate-gradient training Zhang et al. (2022); Zhang et al. (2026a), and recent spike-driven transformers demonstrate that attention architectures can also operate entirely on spike events at scale Huang et al. (2024); Qiu et al. (2025); Yao et al. (2025). SNNs are also applied for navigation planning of wheeled robots Tang et al. (2020); Zhang et al. (2024). Meanwhile, SNNs have also been extensively applied to perceptual tasks in autonomous driving, including object detection Vicente-Sola et al. (2025); Zhang et al. (2026a) and semantic segmentation Lei et al. (2025). In autonomous driving planning, however, SNNs have predominantly been confined to open-loop, single-modality perception tasks, with SAD Zhu et al. (2024) serving as a notable benchmark for end-to-end spiking planning on nuScenes. Other specialized endeavors have explored SNNs for spatial path finding Espino et al. (2024) or hybrid designs Fan et al. (2025) leveraging SNNs solely for low-power temporal feature. Nevertheless, current frameworks rarely rely entirely on pure SNN architectures across all processing stages. Therefore, our model aims to develop a fully spike-driven architecture specifically tailored for motion planning in autonomous driving. 2.3 Query-Based Scene Understanding for Planning Figure 2: Overall architecture of the proposed Pipline. Multi-view images are encoded into a Spiking BEV representation via E-Spikeformer and Spike-3D-Lift, which simultaneously supports semantic segmentation and 3D object detection. The planning stage then refines waypoints with a 3-mode reference curve and Deformable SCA, and finally outputs the ego-vehicle trajectory. Query-based decoders, such as Q-Former Li et al. (2023) and deformable attention Zhu et al. (2021), are pivotal in modern vectorized planners Jiang et al. (2023); Sun et al. (2025) for distilling sparse structural queries from dense perception maps. However, their dependence on floating-point Softmax operators fundamentally limits their deployability on neuromorphic hardware. To mitigate this hardware constraint, recent advances in Spiking Transformers—such as Spikformer Zhou et al. (2022) and Spike-driven Transformer Yao et al. (2023)—have successfully eliminated Softmax operations by reformulating self-attention into fully spike-driven, addition-only interactions. Despite these breakthroughs, existing Spiking Transformer architectures are predominantly tailored for standard backbone feature extraction and lack specialized decoders capable of handling multi-task, query-based representation learning. To bridge this gap, we propose Spike-QFormer, which extends the query-based bottleneck paradigm to the spiking domain for end-to-end autonomous driving. 3 Method 3.1 Overall Architecture The overall architecture of our proposed SDPAD is depicted in Fig. 2. Firstly, multi-view images (6×3×H×W)(6× 3× H× W) are processed by the E-Spikeformer Yao et al. (2025) backbone to yield image features and spiking depth scores, which are subsequently lifted to the BEV space via Spike-3D-Lift, forming the Spiking BEV representation. Then, this representation is fed into Spike-SegHead and Spike-AgentHead for semantic segmentation and 3D object detection, respectively. Concurrently, map, ego, and agent queries from the embedding library are integrated through Spike-QFormer modules to get waypoint query. Finally, the planning stage refines waypoints based on a 3-mode reference curve and Deformable Spike-Cross-Attention (SCA), and employs a Spike-MLP to output the final predicted trajectory for the ego vehicle. 3.2 Preliminary Spiking Neuron Dynamics. We employ the iterative Leaky Integrateand-Fire (I-LIF) model neuron with a soft-reset mechanism Guo et al. (2024). At time step t, its discrete-time state transitions are formulated as: U[t]=H[t−1]+X[t],U[t]=H[t-1]+X[t], (1) S[t]=θ(U[t]−Vth),S[t]=θ(U[t]-V_th), (2) H[t]=U[t]−Vth⋅S[t],H[t]=U[t]-V_th· S[t], (3) where U[t]U[t], H[t]H[t], and X[t]X[t] denote the pre-fire, post-reset membrane potentials, and spatial input, respectively. VthV_th is the firing threshold, S[t]∈0,1S[t]∈\0,1\ is the output spike, and θ(⋅)θ(·) is the Heaviside step function. Integer ANN2SNN Conversion. In rate-coded ANN-to-SNN conversion over a temporal window T, the layer-l SNN firing rate maps to the ANN activation via alT=1T∑t=1TSl[t]a_l^T= 1T _t=1^TS_l[t]. To minimize the conversion gap, the source integer ANN is optimized using a quantized-clip activation: alT=h(Ul)=1T⌊clip(Ul,0,T)⌉,a_l^T=h(U^l)= 1T (U^l,0,T) , (4) where ⌊⋅⌉ · denotes the rounding operation and UlU^l is the pre-activation potential. Upon conversion, the total accumulated SNN membrane potential over T steps is given by Ul=Hl[0]+(1TWl)∑d=1TSl−1[t]U^l=H^l[0]+( 1TW^l) _d=1^TS^l-1[t], where WlW^l is the weight matrix. Consequently, the sequential dynamics in Eq. (2) can be parallelized over the temporal window as: Sl[t]=θ(Ul−Vth⋅t)t=1T. \S^l[t]=θ(U^l-V_th· t) \_t=1^T. (5) This integer-driven framework effectively minimizes the mapping error and mitigates residual potential variance. 3.3 Spike-Driven-Max for Spike-3D-Lift Figure 3: The illustration of the Spike-3D-Lift for Spike-BEV generation process. Image features are weighted by the accumulated spiking depth scores to form 3D frustum features (membrane potentials), followed by camera-based interpolation and spiking neural conversion to Spiking BEV Representation. To achieve energy-efficient 2D-to-3D feature lifting (e.g., in LSS architectures Philion and Fidler (2020)) while preserving accurate spatial layout, we propose the Spike-Driven-Max (SDM) mechanism, as shown in Fig. 3. Unlike traditional methods that rely on dense, floating-point Softmax depth distributions, SDM quantizes the continuous depth estimation into discrete, integer-valued spike intensities, enabling hardware-friendly spike-driven matrix multiplication. Specifically, given the continuous depth input D, we first restrict its range and apply a rounding operation to generate discrete spike states D D: D^=⌊clip(D,Dmin,Dmax)⌉, D= (D,D_ ,D_ ) , (6) To capture the non-linear significance of deeper ranges, we employ an exponential mapping to yield the raw spike activation M=D^⋅2D^−DmaxM= D· 2 D-D_ . To bridge the quantization gap flexibly, we introduce a learnable normalization factor N=Dmax+softplus(α)N=D_ +softplus(α), where α is a trainable parameter initialized dynamically. The final normalized sparse spike output SDS_D is formulated as: SD=max(M,ϵ)N,S_D= (M,ε)N, (7) where ϵε is a small constant to prevent division by zero. Since the rounding operation in Eq. 6 is non-differentiable, we adopt the Straight-Through Estimator (STE) in the backward pass, approximating the gradient as ∂D^∂D≈1 ∂ D∂ D≈ 1 within the active range [Dmin,Dmax][D_ ,D_ ]. Finally, the 3D frustum membrane potential VℱV_F is constructed via matrix multiplication between the discrete spiking depth score SDS_D and the continuous visual context features I: Vℱ=(SD)⊗(I),V_F=P(S_D) (I), (8) where (⋅)P(·) represents the tensor permutation adjusting axes for batch matrix alignment. Because SDS_D represents scaled discrete spike states rather than dense floating-point probabilities, Eq. 9 degenerates into a spike-driven linear accumulation in neuromorphic hardware, drastically reducing computational FLOPs while preserving representation capacity. We then draw inspiration from the Radial-Cartesian BEV Sampling technique Zhang et al. (2025). In our approach, we first pre-define the coordinates of the Cartesian Spiking BEV features Sbev∈ℝC×X×YS_bev ^C× X× Y, and subsequently project them onto the current membrane potential Vℱ∈ℝC×D×WV_F ^C× D× W. After this projection, spike firing is triggered in the neurons. The operation can be formally expressed as: Sbev(x,y)=(Vℱ|Proj(x,y)Bilinear),S_bev(x,y)=SN(V_F|^Bilinear_Proj(x,y)), (9) where Proj(x,y)Proj(x,y) denotes the coordinates of the projected point (x,y)(x,y) on VℱV_F, bilinear sampling is utilized to retrieve the corresponding membrane potential, (⋅)SN(·) denotes spiking neuron layer with I-LIF neuron. 3.4 Spike-QFormer for Waypoint Decoding Inspired by the Q-Former architecture Li et al. (2023), which employs learnable queries to extract task-relevant information from frozen visual features via cross-attention, we propose the Spike-QFormer, a fully spike-driven querying transformer that aggregates heterogeneous driving context into waypoint predictions. As illustrated in Fig. 2, the Spike-QFormer is built upon a single shared primitive—spiking attention—which is instantiated into two query decoders that progressively distill the BEV scene representation into three complementary query groups (ego, agent, and map), followed by a waypoint query decoder that fuses them for trajectory generation. Spiking attention primitive. All query decoders in the Spike-QFormer share a unified spiking attention operator. Given a learnable embedding as input query XqX_q and a key–value sequence XkvX_kv, spike projections are obtained as Q~=(Wq(Xq)) Q=SN(W_qSN(X_q)), K~=(Wk(Xkv)) K=SN(W_kSN(X_kv)) and V~=(Wv(Xkv)) V=SN(W_vSN(X_kv)), where the inputs are quantized into integer spike trains by (⋅)SN(·) both before and after each linear projection. The attention output is then computed without softmax normalization: (Xq,Xkv)=(Q~K~⊤V~⋅2vscale)Wo,SA(X_q,X_kv)=SN\! ( Q K V· 2v_scale )W_o, (10) where vscalev_scale is the scaling constant. Since Q~ Q, K~ K and V~ V are all integer-valued spike tensors, both matrix multiplications degenerate into spike-gated accumulations, and the softmax, whose exponentiation and division are costly on neuromorphic hardware, is entirely removed. A spike-driven MLP follows the attention in each decoder layer, and residual connections are preserved. Multi-source query construction. We construct three complementary query groups from the heterogeneous driving context. All groups are learnable embeddings that extract information from the BEV representation through spiking decoder layers, each consisting of spiking self-attention, spiking cross-attention and a spike-driven MLP. The ego query ego∈ℝ1×DQ_ego ^1× D and the agent queries agent∈ℝNa×DQ_agent ^N_a× D (Na=30N_a=30) summarize the ego vehicle’s kinematic state and the instance-level motion of surrounding participants, respectively. To inject the ego status, the CAN-bus signals and the one-hot navigation command are encoded into a status token status=Ws[can;cmd]v_status=W_s[\,c_can;\,c_cmd\,], which is appended to the downsampled 10×1010×10 BEV grid beva∈ℝ100×DF_bev^a ^100× D: [ego;agent]=Dsn3(ta,[flt(beva);status]+kv),[\,Q_ego;\,Q_agent\,]=D^3_sn\! (E_ta,\,[\,flt(F_bev^a);\,v_status\,]+E_kv ), (11) where flt(⋅)flt(·) denotes the flattening operation, taE_ta and kvE_kv are learned query and key embeddings and Dsn3D_sn^3 stacks three spiking decoder layers. The agent queries are additionally supervised by an auxiliary agent-state prediction head, encouraging explicit instance-level representations. Meanwhile, the map queries map∈ℝNb×DQ_map ^N_b× D (Nb=16N_b=16) distill navigation-relevant semantics, road geometry, lane topology and drivable area, from the full-resolution BEV features, which are fused with the agent-view BEV features through a spike-driven projection: map=Dsn3(map,flt(^bev)),Q_map=D^3_sn\! (E_map,\,flt( F_bev) ), (12) where ^bev F_bev is the fused BEV feature map. Waypoint querying via cross-attention. The waypoint decoder treats learnable waypoint tokens as information-seeking queries attending to the fused multi-source context. We maintain waypoint embeddings wp,pos∈ℝK×L×2DE_wp,E_pos ^K× L× 2D, where K=3K=3 denotes the navigation commands (left, straight, right) and L is the prediction length. The three query groups are concatenated into a unified context fused=[ego;agent;map]Q_fused=[\,Q_ego;\,Q_agent;\,Q_map\,], and a single-layer spiking cross-attention generates the waypoint representations: ¯=(wp+pos,fused). W=SA\! (E_wp+E_pos,\,Q_fused ). (13) Finally, a Spike-MLP decodes each waypoint token into per-step displacements, which are cumulatively summed to construct K candidate trajectories. The trajectory corresponding to the active navigation command is then selected as the final planning output. 3.5 Deformable Spike-Cross-Attention To ground the waypoint tokens in fine-grained spatial evidence, we refine them with a Deformable Spike-Cross-Attention (Deformable SCA) module, which couples the adaptive spatial sampling of deformable attention Zhu et al. (2021) with an all-spike computation paradigm. Unlike conventional deformable attention that relies on continuous softmax weights, Deformable SCA replaces every floating-point attention computation with spike-driven operations. Given waypoint tokens ∈ℝNq×Dq ^N_q× D, BEV membrane potential ∈ℝNv×Dv ^N_v× D and reference points ∈[0,1]Nq×2p∈[0,1]^N_q× 2 given by the initial trajectory, both inputs are first quantized by the spiking neuron layer (⋅)SN(·), and the sampling offsets, attention weights and value projection are predicted from the spiking features: Δ=Wp~,=(Wa~),=Wv~, =W_p q, =SN\! (W_a q ), =W_v v, (14) where ~=() q=SN(q) and ~=() v=SN(v). The sampling locations are obtained by combining the reference points with the predicted offsets, normalized by the spatial shape (Xl,Yl)(X_l,Y_l) of each feature level: ^hlk=+Δhlk⊘(Xl,Yl) p_hlk=p+ _hlk (X_l,Y_l). Deformable SCA then aggregates the sampled features with the spiking attention weights through bilinear sampling: DeformSCA(,,)= (q,v,p)= (15) (∑h=1H∑l=1L∑k=1Phlk⊙h|^hlkbilinear)Wo+, \! ( _h=1^H _l=1^L _k=1^PA_hlk \!V_h|^bilinear_ p_hlk )W_o+q, where h indexes H attention heads, k indexes P sampling points, and a residual connection with the input tokens is preserved. 3.6 Loss The overall training objective combines four task-specific losses. BEV segmentation loss. A cross-entropy loss over the 200×200200×200 BEV grid for semantic map supervision: ℒseg=−∑cyclog(y^c),L_seg=-Σ _cy_c ( y_c), (16) where c indexes the semantic classes. Agent detection loss. A binary cross-entropy loss on the existence logits of the Na=30N_a=30 agent slots plus an L1L_1 regression loss on their states: ℒagent=λclsℒBCE(p^,p∗)+λboxℒL1(^,∗),L_agent= _clsL_BCE( p,p^*)+ _boxL_L1( s,s^*), (17) with λcls=0.85 _cls=0.85 and λbox=0.1 _box=0.1. Planning loss. A command-conditioned L1L_1 loss over valid future horizons, applied to both the initial trajectories (ℒplaninitL_plan^init) and the refined ones (ℒplanrefL_plan^ref): ℒplan=1Z∑twtcmd⋅mt⋅|τ^t−τt∗|1,L_plan= 1ZΣ _tw_t^cmd· m_t· | τ_t- _t^* |_1, (18) where wtcmdw_t^cmd is the command-guided mode weight, mtm_t masks invalid timesteps, and Z is the number of valid steps. Depth loss. A binary cross-entropy loss ℒdepthL_depth supervising the depth distribution in Spike-3D-Lift. The total loss is ℒ=λsegℒseg+ℒagent+λplan(ℒplaninit+ℒplanref)+λdepthℒdepth,L= _segL_seg+L_agent+ _plan (L_plan^init+L_plan^ref )+ _depthL_depth, (19) with λseg=1.1 _seg=1.1, λplan=10.0 _plan=10.0 and λdepth=0.1 _depth=0.1. 4 Experiments Table 1: Comparison on nuScenes dataset with open-loop metrics. metric calculated in the same way as VAD Method SNN Img. Backbone Auxiliary Task L2 (m) ↓ Collision Rate (%) ↓ Energy (mJ) ↓ 1s 2s 3s Avg. 1s 2s 3s Avg. ST-P3 Hu et al. (2022) ✗ EffNet-b4 Det& Map 1.33 2.11 2.90 2.11 0.23 0.62 1.27 0.71 3520.40 UniAD Hu et al. (2023) ✗ ResNet-101 Det&Track&Map&Motion&Occ 0.45 0.70 1.04 0.73 0.62 0.58 0.63 0.61 - VAD Jiang et al. (2023) ✗ ResNet-50 Det&Map&Motion 0.41 0.70 1.05 0.72 0.07 0.17 0.41 0.22 - SparseDrive Sun et al. (2025) ✗ ResNet-50 Det&Track&Map&Motion 0.29 0.58 0.96 0.61 0.01 0.05 0.18 0.08 - DiffusionDrive Liao et al. (2025) ✗ ResNet-50 Det&Track&Map&Motion 0.27 0.54 0.90 0.57 0.03 0.05 0.16 0.08 - ResWorld Zhang et al. (2026b) ✗ ResNet-50 None 0.14 0.27 0.49 0.30 0.01 0.03 0.14 0.06 4103.74 SAD Zhu et al. (2024) ✓ STM Det&Map 1.53 2.35 3.21 2.36 0.62 1.26 2.38 1.41 46.92 SDPAD(ours) ✓ E-SpikeFormer None 0.20 0.37 0.65 0.41 0.02 0.09 0.27 0.13 65.88 Det& Map 0.19 0.36 0.64 0.40 0.02 0.09 0.26 0.12 69.93 Table 2: Comparison of state-of-the-art methods on the NAVSIM navtest split. Method SNN Img. Backbone Auxiliary Task NAC ↑ DAC ↑ TTC ↑ Comf. ↑ EP ↑ PDMS ↑ Energy (mJ) ↓ Transfuser Chitta et al. (2022) ✗ ResNet-34 Det&Map 97.7 92.8 92.8 100 79.2 84.0 114.46 UniAD Hu et al. (2023) ✗ ResNet-34 Det&Map 97.8 91.9 92.9 100 78.8 83.4 - VADv2 Chen et al. (2024b) ✗ ResNet-34 Det&Map 97.2 89.1 91.6 100 76.0 80.9 - Hydra-MDP-W-EP Li et al. (2024) ✗ ResNet-34 Det&Map 98.3 96.0 94.6 100 78.7 86.5 - LAW Li et al. (2025) ✗ ResNet-34 None 96.4 95.4 88.7 99.9 81.7 84.6 - World4Drive Zheng et al. (2025) ✗ ResNet-34 None 97.4 94.3 92.8 100 79.9 85.1 - DiffusionDrive Liao et al. (2025) ✗ ResNet-34 Det&Map 98.2 96.2 94.7 100 82.2 88.1 153.22 ResWorld Zhang et al. (2026b) ✗ ResNet-34 Det&Map 98.9 96.5 95.6 100 83.1 89.0 - SAD Zhu et al. (2024) ✓ STM Det&Map 96.3 92.2 91.0 98.9 77.7 82.0 20.92 SDPAD(ours) ✓ E-SpikeFormer None 97.8 93.9 93.6 99.9 79.9 85.3 32.34 Det&Map 97.7 95.1 93.8 100 80.7 86.3 34.38 4.1 Benchmarks Open-Loop Metrics on nuScenes. Developed to capture diverse real-world driving environments, the nuScenes benchmark Caesar et al. (2020) provides 1,000 driving scenes for open-loop testing. We evaluate the predicted future trajectories, sampled at 2 Hz for a duration of 3 seconds, by calculating the L2L_2 displacement error and Collision Rate (CR), remaining consistent with existing methodologies Hu et al. (2023); Jiang et al. (2023). Closed-Loop Assessment in NAVSIM. Based on the extensive OpenScene dataset Contributors (2023) (>100,000>100,000 keyframes across 1,1921,192 train and 136136 test scenarios), the NavSim simulator Dauner et al. (2024) serves as our closed-loop validation environment. To align with the official baseline, an LQR controller is applied to interpolate the 4-second, 2 Hz predicted trajectories. Ultimately, the framework evaluates driving behavior via the Planning Decision Metric Score (PDMS), which integrates five essential driving criteria: No at-fault Collision (NC), Drivable Area Compliance (DAC), Time-to-Collision (TTC), Comfort (Comf.), and Ego Progress (EP). 4.2 Implementation Details nuScenes. We adopt the large model of E-SpikeFormer Yao et al. (2025) (19M19M parameters) as the feature extractor for our model. Multi-view images downsampled to 256×704256× 704 are used as input. We adopt Radial-Cartesian-Sampling Zhang et al. (2025) as the the BEV feature projection method, where membrane potentials are projected into BEV features based on spike proportion before computing spike firing. For navigation commands, we followed the work Hu et al. (2023), comprising three types: left, right, and straight. In the decoder, we generate three planning trajectories (each with 6 points over 3 seconds) and select the one corresponding to the navigation command. The model is trained on 2 NVIDIA A800 GPUs with a total batch size of 20 for 30 epochs. We use the AdamW optimizer with an initial learning rate of 6×10−46× 10^-4, decayed using a step schedule. We also verify the effect of auxiliary tasks on the final waypoint prediction. We further conduct ablation studies on the nuScenes benchmark to evaluate the effectiveness of the proposed components and the impact of spiking neural networks on performance. NAVSIM. For experiments conducted on NAVSIM benchmark, we use two E-SpikeFormer backbone networks equipped with spiking attention to process the concatenated images and LiDAR BEV maps, similar to Tansfuser Chitta et al. (2022). Based on the fusion of LiDAR and image information in the backbone with spiking attention, this architecture can directly use the final LiDAR features as BEV features for Spike-Qformer. Waypoints are predicted as an 8-waypoint trajectory over 44 seconds. The model is also trained on 2 NVIDIA A800 GPUs for 100 epochs with a learning rate of 6×10−46× 10^-4. 4.3 Main Results nuScenes. We conducted comprehensive comparisons between SDPAD and existing autonomous driving methods on the nuScenes benchmark as shown in Tab. 1. It can be found that SDPAD achieves highly competitive planning accuracy compared to state-of-the-art ANN methods. Specifically, our method delivers comparable performance to heavy ANN baselines such as SparseDrive Sun et al. (2025) and DiffusionDrive Liao et al. (2025), while inherently benefiting from the ultra-low energy consumption and temporal sparsity of SNNs. Crucially, when compared with recent SNN-based driving models, SDPAD demonstrates a significant advantage over SAD Zhu et al. (2024), achieving superior trajectory prediction accuracy. On nuScenes, the use of auxiliary tasks does not lead to a significant improvement in waypoint prediction, with the 3-second L2 error differing by merely 0.010.01. This indicates that our fully spike-driven framework retains robust spatiotemporal feature extraction capabilities, successfully bridging the performance gap between neuromorphic architectures and dense ANN models without relying on power-hungry computations. ID Ego Query Agent Query Map Query Deformable -SCA Param. (M)↓ L2 (m) ↓ Collision Rate (%) ↓ Energy (mJ) ↓ 1s 2s 3s 1s 2s 3s 1 ✗ ✗ ✓ ✗ 34.91 0.28 0.57 0.98 0.04 0.19 0.44 69.27 2 ✓ ✗ ✓ ✗ 38.11 0.27 0.56 0.97 0.02 0.16 0.51 68.71 3 ✗ ✓ ✓ ✗ 38.38 0.20 0.39 0.70 0.02 0.12 0.35 69.58 4 ✓ ✓ ✗ ✗ 35.21 0.21 0.38 0.67 0.02 0.11 0.34 70.02 5 ✓ ✓ ✓ ✗ 38.39 0.20 0.38 0.66 0.02 0.12 0.30 69.64 6 ✓ ✓ ✓ ✓ 38.70 0.19 0.36 0.64 0.02 0.09 0.26 69.93 Table 3: Ablation for design choices. quant- steps L2 (m) ↓ Collision Rate (%) ↓ Energy (mJ) ↓ 1s 2s 3s 1s 2s 3s 2 2.32 3.81 5.32 2.05 4.94 6.12 79.08 3 0.22 0.40 0.66 0.02 0.09 0.31 84.74 4 0.20 0.38 0.66 0.02 0.11 0.26 76.64 8 0.19 0.36 0.64 0.02 0.09 0.26 69.93 Table 4: Ablation study of SNN quantization steps. Depth Att. MFLOPs (Att.) mIoU (%) ↑ mAP:0.5 (%) ↑ L2 (m) ↓ Collision Rate (%) ↓ 1s 2s 3s 1s 2s 3s Softmax 45.96 38.79 15.30 0.19 0.37 0.65 0.02 0.09 0.26 SpareMax 10.25 29.06 10.37 0.20 0.37 0.66 0.04 0.11 0.32 I-LIF 23.06 17.48 2.23 0.21 0.39 0.68 0.04 0.12 0.39 SDM 35.13 36.60 13.94 0.19 0.36 0.64 0.02 0.09 0.26 Table 5: Ablation study of depth attention for BEV. NAVSIM. We also evaluated the closed-loop planning accuracy of SDPAD on the NAVSIM benchmark, and the experimental results are presented in Tab. 2. To conduct a fair comparison, we evaluated our model against both ANN-based and SNN-based planners. Notably, SDPAD achieves 86.3%86.3\% PDMS, exhibiting planning accuracy that is highly comparable to mainstream ANN methods like Hydra-MDP Li et al. (2024) and World4Drive Zheng et al. (2025), yet operating at a fraction of their computational footprint. Furthermore, our proposed method outperforms existing spiking models such as SAD by a notable margin of 4.34.3 PDMS points, proving the efficacy of our architectural design in handling complex closed-loop scenarios. On NAVSIM, our method with auxiliary tasks contributes a 1%1\% improvement to the final PDMS. The complete SDPAD leverages the integer-spike representation of spiking neurons to represent the dynamic information of the driving scene, demonstrating that a fully spike-driven pipeline can maintain exceptional safety and planning precision in realistic navigation tasks. 4.4 Ablation Studies Effect of designs in spiking decoder. Tab. 3 shows the contribution of each component in our proposed decoder. ID-1 (only Map Query) serves as the baseline, achieving an L2 of 0.98m0.98~m and a collision rate of 0.44%0.44\%. Adding the Ego Query (ID-2) or the Agent Query (ID-3) individually reduces the L2 to 0.97m0.97~m and 0.70m0.70~m respectively, demonstrating the importance of ego and agent information. When both ego and agent query are included without the Map Query (ID-4), the L2 further drops to 0.67m0.67~m. The full combination of Ego, Agent and Map Query (ID-5) yields an L2 of 0.66m0.66~m and a collision rate of 0.30%0.30\%. Finally, incorporating Deformable-SCA in ID-6 achieves the best performance: 0.64m0.64~m L2 and 0.26%0.26\% collision rate, with only a modest increase in parameters (39M39M vs. 35M35M of baseline). This validates that rich query interactions and attention mechanisms are crucial for high-quality planning. Efficiency of quantization steps in SNN. Since our integer-spike representation encodes the firing count of T conversion steps in a single value, varying TmaxT_max is equivalent to varying the effective time window of the converted SNN, without actually unrolling it at inference. Tab. 5 studies the effect of the number of quantization steps in our spiking neural network. Increasing the quantization steps from 22 to 88 consistently improves the planning quality: L2 decreases from 5.32m5.32~m to 0.64m0.64~m, and the collision rate drops from 6.12%6.12\% to 0.26%0.26\%. However, higher quantization steps do not increase energy: the energy cost even decreases slightly from 84.73 mJ (quant-steps 3) to 69.93 mJ (quant-steps 8), because coarser quantization produces denser spike firing. Notably, even with only 22 quantization steps, our model already achieves reasonable results, and additional steps provide further gains in complex scenarios. Depth attention for BEV construction. To validate the efficacy of our SDM within the Spike-3D-Lift mechanism, we conduct comparative experiments against Softmax, SparseMax Martins and Astudillo (2016), and I-LIF variants, with the results summarized in Tab. 5. Compared to the conventional Softmax attention, our SDM module reduces computational overhead by 23.6%23.6\% (from 45.9645.96 to 35.1335.13 MFLOPs) while maintaining competitive perception performance (36.60%36.60\% mIoU and 13.94%13.94\% mAP:0.5). Crucially, SDM achieves superior or on-par motion planning accuracy across all prediction horizons (1s1s–3s3s), yielding an L2 error of 0.64m0.64m and a low collision rate of 0.26%0.26\% at 3s3s. While SparseMax and I-LIF lower computational complexity further, they suffer from severe degradation in perception fidelity—most notably I-LIF’s drop to 17.48%17.48\% mIoU—which adversely propagates to planning safety. These results demonstrate that SDM strikes an optimal trade-off between energy/computational efficiency and end-to-end task performance. 5 Conclusion In this work, we have presented SDPAD, a fully spike-driven pipeline for end-to-end autonomous driving, by incorporating integer ANN2SNN conversion, a spike-driven-max mechanism for BEV lifting, and the Spike-QFormer planning decoder with deformable spike-cross-attention refinement. SDPAD performs the entire perception-to-planning computation on integer spike representations in a single feed-forward pass, without any temporal simulation loops. Comprehensive experiments on nuScenes and NAVSIM validate the superiority of SDPAD in planning quality, energy efficiency, and closed-loop safety, demonstrating that spiking architectures can rival dense ANN planners in complex driving tasks at a small fraction of their energy cost. We believe SDPAD provides a blueprint for future ultra-efficient edge AI vehicles, and leave direct surrogate-gradient training and on-chip neuromorphic deployment as future work. References Caesar et al. (2020) H. Caesar, V. Bankiti, A. H. Lang, S. Vora, V. E. Liong, Q. Xu, A. Krishnan, Y. Pan, G. Baldan, and O. Beijbom Nuscenes: a multimodal dataset for autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 11621–11631. Cited by: §4.1. Chen et al. (2024a) L. Chen, P. Wu, K. Chitta, B. Jaeger, A. Geiger, and H. Li End-to-end autonomous driving: challenges and frontiers. IEEE Transactions on Pattern Analysis and Machine Intelligence 46 (12), p. 10164–10183. Cited by: §1. Chen et al. (2024b) S. Chen, B. Jiang, H. Gao, B. Liao, Q. Xu, Q. Zhang, C. Huang, W. Liu, and X. Wang Vadv2: end-to-end vectorized autonomous driving via probabilistic planning. arXiv preprint arXiv:2402.13243. Cited by: §2.1, Table 2. Chitta et al. (2022) K. Chitta, A. Prakash, B. Jaeger, Z. Yu, K. Renz, and A. Geiger Transfuser: imitation with transformer-based sensor fusion for autonomous driving. IEEE transactions on pattern analysis and machine intelligence 45 (11), p. 12878–12895. Cited by: §4.2, Table 2. Contributors (2023) O. Contributors Openscene: the largest up-to-date 3d occupancy prediction benchmark in autonomous driving. In Proceedings of the Conference on Computer Vision and Pattern Recognition, Vancouver, Canada, p. 18–22. Cited by: §4.1. Dauner et al. (2024) D. Dauner, M. Hallgarten, T. Li, X. Weng, Z. Huang, Z. Yang, H. Li, I. Gilitschenski, B. Ivanovic, M. Pavone, et al. Navsim: data-driven non-reactive autonomous vehicle simulation and benchmarking. Advances in Neural Information Processing Systems 37, p. 28706–28719. Cited by: §2.1, §4.1. Ding et al. (2021) J. Ding, Z. Yu, Y. Tian, and T. Huang Optimal ann-snn conversion for fast and accurate inference in deep spiking neural networks. arXiv preprint arXiv:2105.11654. External Links: 2105.11654, Link Cited by: §2.2. Espino et al. (2024) H. Espino, R. Bain, and J. L. Krichmar A rapid adapting and continual learning spiking neural network path planning algorithm for mobile robots. IEEE Robotics and Automation Letters 9 (11), p. 9542–9549. Cited by: §2.2. Fan et al. (2025) Y. Fan, Z. Cui, Z. Li, Y. Ren, and H. Yu SAH-drive: a scenario-aware hybrid planner for closed-loop vehicle trajectory generation. arXiv preprint arXiv:2505.24390. Cited by: §2.2. Guo et al. (2024) Y. Guo, Y. Chen, X. Liu, W. Peng, Y. Zhang, X. Huang, and Z. Ma Ternary spike: learning ternary spikes for spiking neural networks. In Proceedings of the AAAI conference on artificial intelligence, Vol. 38, p. 12244–12252. Cited by: §3.2. Hu et al. (2022) S. Hu, L. Chen, P. Wu, H. Li, J. Yan, and D. Tao St-p3: end-to-end vision-based autonomous driving via spatial-temporal feature learning. In European Conference on Computer Vision, p. 533–549. Cited by: §1, Table 1. Hu et al. (2023) Y. Hu, J. Yang, L. Chen, K. Li, C. Sima, X. Zhu, S. Chai, S. Du, T. Lin, W. Wang, et al. Planning-oriented autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 17853–17862. Cited by: §1, §2.1, §4.1, §4.2, Table 1, Table 2. Huang et al. (2024) Z. Huang, X. Shi, Z. Hao, T. Bu, J. Ding, Z. Yu, and T. Huang Towards high-performance spiking transformers from ann to snn conversion. In Proceedings of the 32nd ACM international conference on multimedia, p. 10688–10697. Cited by: §2.2. Jiang et al. (2023) B. Jiang, S. Chen, Q. Xu, B. Liao, J. Chen, H. Zhou, Q. Zhang, W. Liu, C. Huang, and X. Wang Vad: vectorized scene representation for efficient autonomous driving. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 8340–8350. Cited by: §1, §2.1, §2.3, §4.1, Table 1. Lei et al. (2025) Z. Lei, M. Yao, J. Hu, X. Luo, Y. Lu, B. Xu, and G. Li Spike2former: efficient spiking transformer for high-performance image segmentation. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39, p. 1364–1372. Cited by: §2.2. Li et al. (2023) J. Li, D. Li, S. Savarese, and S. Hoi BLIP-2: bootstrapping language-image pre-training with frozen image encoders and large language models. In ICML, Cited by: §2.3, §3.4. Li et al. (2025) Y. Li, L. Fan, J. He, Y. Wang, Y. Chen, Z. Zhang, and T. Tan Enhancing end-to-end autonomous driving with latent world model. In International Conference on Learning Representations, Vol. 2025, p. 42942–42959. Cited by: §1, §2.1, Table 2. Li et al. (2024) Z. Li, K. Li, S. Wang, S. Lan, Z. Yu, Y. Ji, Z. Li, Z. Zhu, J. Kautz, Z. Wu, et al. Hydra-mdp: end-to-end multimodal planning with multi-target hydra-distillation. arXiv preprint arXiv:2406.06978. Cited by: §4.3, Table 2. Liao et al. (2025) B. Liao, S. Chen, H. Yin, B. Jiang, C. Wang, S. Yan, X. Zhang, X. Li, Y. Zhang, Q. Zhang, et al. Diffusiondrive: truncated diffusion model for end-to-end autonomous driving. In Proceedings of the Computer Vision and Pattern Recognition Conference, p. 12037–12047. Cited by: §1, §2.1, §4.3, Table 1, Table 2. Martínez et al. (2024) F. S. Martínez, J. Casas-Roma, L. Subirats, and R. Parada Spiking neural networks for autonomous driving: a review. Engineering Applications of Artificial Intelligence 138, p. 109415. Cited by: §1. Martins and Astudillo (2016) A. Martins and R. Astudillo From softmax to sparsemax: a sparse model of attention and multi-label classification. In International conference on machine learning, p. 1614–1623. Cited by: §4.4. Philion and Fidler (2020) J. Philion and S. Fidler Lift, splat, shoot: encoding images from arbitrary camera rigs by implicitly unprojecting to 3d. In European conference on computer vision, p. 194–210. Cited by: §3.3. Qiu et al. (2025) X. Qiu, J. Zhang, W. Wei, H. Cao, J. Guo, R. Zhu, Y. Shan, Y. Yang, M. Zhang, and H. Li Quantized spike-driven transformer. In The Thirteenth International Conference on Learning Representations, External Links: Link Cited by: §2.2. Sun et al. (2025) W. Sun, X. Lin, Y. Shi, C. Zhang, H. Wu, and S. Zheng Sparsedrive: end-to-end autonomous driving via sparse scene representation. In 2025 IEEE International Conference on Robotics and Automation (ICRA), p. 8795–8801. Cited by: §2.1, §2.3, §4.3, Table 1. Tang et al. (2020) G. Tang, N. Kumar, and K. P. Michmizos Reinforcement co-learning of deep and spiking neural networks for energy-efficient mapless navigation with neuromorphic hardware. Cited by: §2.2. Vicente-Sola et al. (2025) A. Vicente-Sola, D. L. Manna, P. Kirkland, G. Di Caterina, and T. J. Bihl Spiking neural networks for event-based action recognition: a new task to understand their advantage. Neurocomputing 611, p. 128657. Cited by: §2.2. Yang et al. (2025a) B. Yang, S. Zhou, C. Lin, Q. Chai, R. Yan, D. Ma, G. Pan, and H. Tang HSRL: a hierarchical control system based on spiking deep reinforcement learning for robot navigation. In 2025 IEEE International Conference on Robotics and Automation (ICRA), p. 13384–13390. Cited by: §1. Yang et al. (2025b) Y. Yang, J. Mei, Y. Ma, S. Du, W. Chen, Y. Qian, Y. Feng, and Y. Liu Driving in the occupancy world: vision-centric 4d occupancy forecasting and planning via world models for autonomous driving. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39, p. 9327–9335. Cited by: §1. Yao et al. (2023) M. Yao, J. Hu, Z. Zhou, L. Yuan, Y. Tian, B. Xu, and G. Li Spike-driven transformer. Advances in neural information processing systems 36, p. 64043–64058. Cited by: §2.3. Yao et al. (2025) M. Yao, X. Qiu, T. Hu, J. Hu, Y. Chou, K. Tian, J. Liao, L. Leng, B. Xu, and G. Li Scaling spike-driven transformer with efficient spike firing approximation training. IEEE Transactions on Pattern Analysis and Machine Intelligence 47 (4), p. 2973–2990. Cited by: §2.2, §3.1, §4.2. Zhang et al. (2024) C. Zhang, K. W. Yip, B. Yang, Z. Zhang, M. Yuan, R. Yan, and H. Tang CASRL: collision avoidance with spiking reinforcement learning among dynamic, decision-making agents. 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), p. 8031–8038. Cited by: §2.2. Zhang et al. (2026a) C. Zhang, Y. Zhang, J. Yu, J. Yang, and M. Sawan Event-fused hybrid ann-snn architecture for low-latency object detection in automotive vision. IEEE Robotics and Automation Letters 11. Cited by: §2.2. Zhang et al. (2022) D. Zhang, S. Jia, and Q. Wang Recent advances and new frontiers in spiking neural networks. arXiv preprint arXiv:2204.07050. External Links: 2204.07050, Link Cited by: §2.2. Zhang et al. (2026b) J. Zhang, Z. Fu, Z. Xu, W. Dai, Q. Liu, and Y. Wang Resworld: temporal residual world model for end-to-end autonomous driving. arXiv preprint arXiv:2602.10884. Cited by: §1, §2.1, Table 1, Table 2. Zhang et al. (2025) J. Zhang, Y. Zhang, Y. Qi, Z. Fu, Q. Liu, and Y. Wang Geobev: learning geometric bev representation for multi-view 3d object detection. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39, p. 9960–9968. Cited by: Table B.6, §3.3, §4.2. Zheng et al. (2025) Y. Zheng, P. Yang, Z. Xing, Q. Zhang, Y. Zheng, Y. Gao, P. Li, T. Zhang, Z. Xia, P. Jia, et al. World4drive: end-to-end autonomous driving via intention-aware physical latent world model. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 28632–28642. Cited by: §1, §2.1, §4.3, Table 2. Zhou et al. (2022) Z. Zhou, Y. Zhu, C. He, Y. Wang, S. Yan, Y. Tian, and L. Yuan Spikformer: when spiking neural network meets transformer. arXiv preprint arXiv:2209.15425. Cited by: §2.3. Zhu et al. (2024) R. Zhu, Z. Wang, L. Gilpin, and J. K. Eshraghian Autonomous driving with spiking neural networks. Advances in Neural Information Processing Systems 37, p. 136782–136804. Cited by: §1, §2.2, §4.3, Table 1, Table 2. Zhu et al. (2021) X. Zhu, W. Su, L. Lu, B. Li, X. Wang, and J. Dai Deformable DETR: deformable transformers for end-to-end object detection. In International Conference on Learning Representations (ICLR), Cited by: §B.2, §2.3, §3.5. Supplementary Material This supplementary material provides implementation details, detailed model architecture specifications, additional experiments for 3D object detection and qualitative visualizations that could not be included in the main paper due to space limitations. Appendix A Implementation Details A.1 ANN pre-training and conversion. We first train the dense ANN counterpart of the perception stack (spike neurons replaced by ReLU, attention by standard multi-head attention) on nuScenes. The pre-trained weights are then converted by replacing every activation with the integer-spike operator (⋅)SN(·) (I-LIF with Vmax=8V_ =8, Eq. (4) of the main paper) while keeping all linear layers unchanged. A.2 Dataset and Input Settings nuScenes. Six surround-view images are downsampled from 900×1600900×1600 to 256×704256×704. During training we apply random scaling in [−0.2,0.2][-0.2,0.2] and horizontal flipping. The BEV grid covers [−15m,15m]×[−30m,30m][-15\,m,15\,m]×[-30\,m,30\,m] with 0.15m×0.3m0.15\,m× 0.3\,m resolution (100×100100×100 cells); the depth range is [1m,35m][1\,m,35\,m] discretized with 0.50.5 m intervals (68 bins). Depth supervision comes from LiDAR point clouds projected onto the image planes. The planner predicts T=6T=6 waypoints over 3 s at 2 Hz, conditioned on three navigation commands (left, straight, right) obtained from the CAN bus. NAVSIM. We follow the official NAVSIM protocol: the input is the concatenation of the front and front-left/right camera images (and the rasterized BEV map for the map-enhanced variant), and the planner predicts 8 waypoints over 4 s. The model is trained for 100 epochs on 2 NVIDIA A800 GPUs with a learning rate of 6×10−46×10^-4. A.3 Energy Measurement Methodology We follow the standard SNN energy model based on 45 nm hardware characterization: E=EMAC⋅NMAC+EAC⋅NAC,E=E_MAC· N_MAC+E_AC· N_AC, (20) with EMAC=4.6E_MAC=4.6 pJ and EAC=0.9E_AC=0.9 pJ per 32-bit operation. Before counting, all BatchNorm layers are folded into their preceding convolutions. For each linear/convolutional layer, the input tensor is examined on the fly: if it is an integer-valued spike tensor, the operation count is scaled by the measured spike firing rate and counted as accumulate (AC) operations; otherwise it is counted as MAC operations. Firing rates are measured per layer over the full validation set and averaged. Energy figures reported in the main paper (Tables 1 and 2) correspond to processing a single frame (nuScenes) or a single simulation step (NAVSIM). ANN baselines are measured with the identical pipeline, where all operations are MACs. Appendix B Model Architecture Details The detailed architecture and parameter specifications of our model are summarized in Tab B.6. Module Specification Image backbone Spike-driven transformer (large), 19.0M embed dims [64,128,256,360][64,128,256,360], stride-16 output Spike-3D-Lift Radial–Cartesian sampling Zhang et al. [2025] SDM depth neuron, Vmax=8V_ =8, BEV channels 80 BEV encoder channels [128,256,360,256,256][128,256,360,256,256], output 256 agent-view features 10×1010×10 Query library 1 ego + 30 agent + 16 map queries, D=256D=256 Ego/Agent decoder 3 spiking layers over 10×1010×10 BEV + status Map decoder 3 spiking layers over fused BEV Waypoint queries K×T=3×6K×T=3×6 tokens, dim 2D=5122D=512 Waypoint decoder 1 spiking cross-attention layer, 8 heads Deformable SCA 8 heads, 8 sampling points, single BEV level Spike neuron I-LIF, Vmin=0V_ =0, Vmax=8V_ =8 Table B.6: Per-stage architecture specification of SDPAD. B.1 Spike-Driven-Max (SDM) Initialization The learnable normalization factor of SDM is N=Dmax+softplus(α)N=D_ +softplus(α) with α initialized to −5-5, so that N≈DmaxN≈ D_ at the beginning of training and the normalization can adapt during fine-tuning. B.2 Deformable SCA Initialization Following Zhu et al. [2021], the sampling-offset weights are initialized to zero and the biases are arranged as concentric rings: head h is assigned angle θh=2πh/H _h=2π h/H, and sampling point k scales the radius linearly with k+1k+1. This provides a structured prior that covers diverse spatial neighborhoods around each reference point before task-specific deformations are learned. The reference point of each waypoint token is given by the corresponding coordinate of the initial (unrefined) trajectory, so spatial sampling is anchored to the model’s own geometric prediction. Appendix C Additional Experimental Results Furthermore, to evaluate the representation capacity of our Spiking BEV features, we conduct experiments on 3D object detection. Specifically, we attach a spike-driven CenterNet head to the BEV features extracted by SDPAD, following the training protocol of GeoBEV. The detection results are summarized in Tab C.7. While the quantized model exhibits a performance gap compared with state-of-the-art ANN-based baselines, it outperforms existing methods such as PETRv2. These results demonstrate that the Spiking BEV features extracted via our SDM effectively encode rich spatial and semantic representations in the Bird’s-Eye-View space. Method Backbone Image Size Frames mAP↑ NDS↑ mATE↓ mASE↓ mAOE↓ mAVE↓ mAAE↓ BEVDet (arXiv. 2021) ResNet50 256×704 1 0.298 0.379 0.725 0.279 0.589 0.860 0.245 PETRv2 (ICCV. 2023) ResNet50 256×704 2 0.349 0.456 0.700 0.275 0.580 0.437 0.187 BEVDepth (AAAI. 2023) ResNet50 256×704 2 0.351 0.475 0.639 0.267 0.479 0.428 0.198 BEVStereo (AAAI. 2023) ResNet50 256×704 2 0.372 0.500 0.598 0.270 0.438 0.367 0.190 SA-BEV (ICCV. 2023) ResNet50 256×704 2 0.387 0.512 0.613 0.266 0.352 0.382 0.199 BEFormerv2 (CVPR. 2023) ResNet50 - - 0.423 0.529 0.618 0.273 0.413 0.333 0.188 SOLOFusion (ICLR. 2023) ResNet50 256×704 17 0.427 0.534 0.567 0.274 0.511 0.252 0.181 StreamPETR (ICCV. 2023) ResNet50 256×704 8 0.450 0.550 0.613 0.267 0.413 0.265 0.196 BEVNext (CVPR. 2024) ResNet50 256×704 8 0.456 0.560 0.530 0.264 0.424 0.252 0.206 RayDN (CVPR. 2024) ResNet50 256×704 8 0.469 0.563 0.579 0.264 0.433 0.256 0.187 GeoBEV (AAAI. 2025) ResNet50 256×704 2 0.415 0.535 0.533 0.265 0.419 0.298 0.214 SDPAD+SpikeCenterNetHead E-Spikeformer 256×704 2 0.352 0.473 0.615 0.276 0.483 0.437 0.218 Table C.7: Comparison with previous state-of-the-art multi-view 3D detectors on the nuScenes val set. Appendix D Qualitative Results In this section, we provide extended qualitative evaluations on representative scenarios from both the nuScenes and NAVSIM benchmarks (Fig D.4 and Fig D.5). The visual comparisons cover intermediate Spiking BEV feature representations, multi-task perception outputs (segmentation and detection), and predicted trajectory quality against the ground truth, demonstrating faithful scene encoding and stable planning." Figure D.4: Predicted trajectories of SDPAD versus ground truth in diverse nuScenes scenarios, together with the BEV segmentation and agent detection outputs. We also show the intermediate Spiking BEV features. Figure D.5: Predicted trajectories of SDPAD versus ground truth in diverse NAVSIM.