May 29, 2026
In recent years, bird’s-eye view (BEV) perception [1]–[4] has emerged as a fundamental representation for autonomous driving, providing a unified interface for 3D object detection and motion planning [5], [6]. Driven by the complementary strengths of cameras and LiDAR, multi-modal fusion has become the dominant paradigm for high-precision BEV perception [7]–[9]. Current state-of-the-art (SOTA) frameworks achieve remarkable performance by aligning heterogeneous sensor streams and integrating dense semantic cues from cameras with precise geometric information from LiDAR into an aligned BEV space [10]–[13].
However, this strong performance relies on an ideal assumption: that all modalities remain reliable at all times [14], [15]. In real-world deployments, sensor streams are often incomplete or corrupted, which poses a fundamental challenge to multi-modal fusion. Crucially, current systems lack the inherent resilience to handle such corruptions. Existing frameworks typically integrate cross-modal representations in a static and tightly coupled manner, making them highly brittle to missing or unreliable modalities [16]–[18]. As illustrated in 1, when the primary geometric modality (e.g., LiDAR) is severely degraded, existing models [2], [3], [19] fail to degrade gracefully and instead suffer an abrupt collapse in performance, often dropping to near-zero accuracy [20], [21]. We attribute this brittleness to a form of modality dominance, referred to in this work as modality laziness, where the model over-relies on the geometry-rich modality during fusion and fails to preserve a viable fallback behavior when that modality becomes unreliable.
To address this challenge, we present Grace-BEV, a lightweight and plug-and-play framework for reliability-aware multi-modal fusion in BEV perception. Rather than relying on static early fusion, we formulate robustness under modality corruption as a dynamic routing problem. Specifically, Grace-BEV operates in the aligned BEV space, where a TrustGate Router explicitly estimates the trustworthiness of the LiDAR stream by assessing its geometric integrity. Based on this real-time reliability assessment, the proposed FailSafe Fusion Block (FFB) dynamically recalibrates cross-modal feature integration, suppressing corrupted signals before they propagate to downstream prediction heads. Furthermore, we devise a Three-Phase Training strategy with Modality Dropout (MD) [13], [22] to prevent modality dominance and encourage balanced cross-modal learning under unreliable inputs. Our main contributions are summarized as follows:
We identify graceful degradation under missing or corrupted modalities as a core challenge for multi-modal BEV perception, and reformulate robust perception as a problem of active modality reliability assessment rather than static feature fusion.
We propose Grace-BEV, a lightweight and plug-and-play framework for reliability-aware multi-modal fusion. The framework introduces a TrustGate Router to explicitly estimate modality trustworthiness and an FFB to dynamically recalibrate feature integration under unreliable inputs.
We further devise a Three-Phase Training strategy with MD to mitigate modality dominance and promote balanced cross-modal learning. Extensive experiments on nuScenes-R and nuScenes-C show that Grace-BEV restores performance from 0.0% to 34.7% mAP under catastrophic LiDAR failures, while also improving clean accuracy by up to 1.4%, achieving a strong trade-off between robustness and efficiency.
Figure 1: Dual-Modality Robustness Analysis. We evaluate Grace-BEV (solid lines) against baselines (dashed lines) on both BEVFusion-MIT (blue) and BEVFusion-AD (orange). (a) When LiDAR fails, baselines suffer a catastrophic collapse to 0 mAP, whereas our method degrades gracefully to the vision-only lower bound. (b) When cameras fail, the performance drop is less severe due to the dominant LiDAR branch. However, our method consistently maintains a higher mAP (+2.2% \(\sim\) +2.4%) across all degradation levels compared to baselines.. a — Robustness to LiDAR Failure., b — Robustness to Camera Failure.
Existing multi-modal 3D detectors for autonomous driving mainly follow two paradigms for constructing BEV representations from heterogeneous data.
Geometry-based alignment approaches, such as Lift, Splat, Shoot (LSS) [23] and BEVFusion [2], [3], [19], [24], [25], explicitly lift image features into 3D space via depth estimation and project them into a unified BEV grid. By leveraging explicit spatial priors to align dense image semantics with sparse point clouds, these methods achieve strong performance and high efficiency under normal conditions. However, their fusion strategies are typically static (e.g., feature concatenation), which can be sensitive to corrupted geometric signals, leading to notable performance degradation under modality failures.
Query- and transformer-based methods, including TransFusion, CMT, and DeepInteraction, model cross-modal interactions through attention mechanisms or learned queries [12], [13], [20], [21], [26]–[30]. While highly expressive and effective, these approaches often introduce additional computational overhead, and robustness is generally learned implicitly within high-dimensional latent spaces [31].
In contrast, our work is motivated by the observation that LSS-based architectures already align multi-modal features explicitly in an aligned BEV space, enabling reliability to be addressed directly at the feature level without resorting to heavy interaction modules.
Robust multi-modal perception is critical for autonomous driving, where sensor failures and degradations are unavoidable [32]–[34]. Existing approaches generally address robustness from two perspectives: training strategies and architectural designs.
Training Strategies. A common practice is MD [22], which randomly removes one modality during training to discourage over-reliance on a dominant modality. While effective as a regularization technique, MD alone is insufficient to ensure robustness. When combined with static fusion structures, the resulting distribution mismatch can significantly degrade detection performance and may even cause unstable optimization or convergence failure [13], [18], [35].
Architectural Designs. Beyond training-time regularization, several works redesign fusion architectures to better handle partial or corrupted observations. Query- or attention-based fusion methods iteratively aggregate multi-modal features [13], [21], [30], while others employ knowledge distillation to transfer geometric priors from LiDAR to camera branches [36]. Although effective, these methods often introduce additional architectural complexity [37], [38].
In contrast, our approach focuses on lightweight, reliability-aware fusion for LSS-based BEV pipelines by explicitly estimating modality reliability and dynamically recalibrating feature integration.
Dynamic routing and conditional computation have been explored in prior work to adapt model behavior based on input characteristics, most notably in Mixture-of-Experts (MoE) frameworks [39], [40]. While conventional MoE designs primarily target capacity scaling or computational efficiency [41], their reliance on heavyweight experts and complex routing policies limits applicability in real-time perception [18], [35]. In contrast, our work adopts the principle of conditional computation for a different purpose: reliability-aware modulation of modality interaction in the aligned BEV space, achieved with minimal architectural overhead.
While multi-modal BEV detectors generally outperform single-modal baselines, their reliability under modality failure remains a critical yet overlooked vulnerability [42]–[45]. As evidenced by our empirical stress tests in 1, standard fusion models exhibit a “cliff-like” performance drop. Specifically, as shown in 1 (a), when LiDAR field of view (FOV) is reduced to \(0^{\circ}\) (simulating a complete sensor blackout), the mean Average Precision (mAP) of baseline methods (dashed lines) collapses to near-zero, indicating a failure to utilize the remaining valid camera signals. Similarly, 1 (b) demonstrates that baselines degrade rapidly even when cameras are lost.
Current attempts to mitigate this fragility often resort to heavy MoE [18], [35] or complex query-based interactions [16], [20], [21], [46]. However, these approaches not only introduce prohibitive computational overhead but also treat robustness as a generic “black-box” learning task, overlooking the specific geometric structure of the problem. Notably, such complexity may be unnecessary for LSS-based architectures [23], where semantic features from different modalities are already explicitly projected and unified into a common BEV coordinate system. In this unified space, multi-modal features are spatially aligned by design. Consequently, achieving robustness does not require searching for valid signals in a high-dimensional latent space; rather, it can be realized efficiently by directly operating on the aligned BEV features.
This insight motivates the design of Grace-BEV, which replaces heavy “implicit learning” with “explicit structural awareness.” Instead of stacking heavy decoders, we propose to leverage the unified BEV space to: 1) explicitly assess the integrity of geometric modality via a lightweight router; and 2) dynamically recalibrate the pre-aligned features via efficient gating. This ensures graceful degradation with minimal architectural modifications, preserving the efficiency inherent to LSS pipelines.
To mitigate the catastrophic degradation inherent in tightly-coupled multi-modal detectors, we propose Grace-BEV, a reliability-aware framework designed to reduce the rigid reliance on potentially corrupted geometric modalities. As illustrated in 2, the architecture follows a lightweight MoE paradigm, orchestrating two distinct pathways via an active routing mechanism [18], [39].
Dual-Expert Architecture. Given multi-view images \(X_{img}\) and LiDAR point clouds \(X_{lidar}\), the system extracts initial features using modality-specific backbones [47]–[50]. To ensure robustness, we construct two parallel experts:
Expert A (LiDAR-Guided): Utilizing the Voxel Encoder outputs \(F_{pts}^{voxel}\), this expert leverages precise geometric priors to project 2D image features into the BEV space [2], [3]. While highly accurate, it is structurally vulnerable to LiDAR corruption.
Expert B (Vision-Only): This expert operates independently of LiDAR inputs, employing a pure vision view transform to construct BEV representations [12], [24]. It acts as a robust semantic safeguard, ensuring system functionality when geometric signals are compromised.
Dynamic Routing and Fusion. Instead of static concatenation, Grace-BEV employs a TrustGate Router to evaluate the integrity of the LiDAR stream based on its feature representation \(F_{pts}^{voxel}\). The router outputs a trust score \(\alpha \in [0, 1]\). Specifically, \(\alpha\) is a sample-adaptive scalar used to softly interpolate the BEV features from the two experts. Subsequently, the FFB integrates the routed features. Unlike standard fusion layers that suffer from distribution shifts under zero-filling, the FFB utilizes an element-wise gating mechanism to actively suppress noise from the corrupted modality. Notably, Grace-BEV is plug-and-play and brings minimal computational overhead, making it highly practical for deployment.
lc *14wc0.88cm & & & & &
(lr)7-14 (lr)15-16 & & & & & & & &
& & & & & & & &
(lr)3-4 (lr)5-6 (lr)7-8 (lr)9-10 (lr)11-12 (lr)13-14 (lr)15-16 & & RD & MRE & mAP & NDS & mAP & NDS & mAP & NDS & mAP & NDS & mAP & NDS & mAP & NDS
DETR3D [27] & 15.6 & - & - & 34.3 & 42.8 & - & - & - & - & - & - & - & - & 0.0 &
0.0
CenterPoint [51] & 6.0 & - & - & 56.3 & 63.4 & 19.7 & 28.9 & 0.0 & 0.0 & 13.2 & 24.3 & 23.4 &
30.1 & - & -
TransFusion [20] & 36.9 & - & - & 66.8 & 70.2 & 40.8 & 52.7 & 0.1 & 0.0 & 20.1 & 39.2 &
33.7 & 46.6 & 61.1 & 66.4
BEVFusion-MIT [2] & 40.8 & - & - & 66.9 & 69.7 & 41.2 & 52.4 & 0.0 & 0.0 & 20.2 & 37.6 &
34.3 & 47.8 & 56.2 & 61.5
BEVFusion-AD [3] & 90.2 & - & - & 68.1 & 70.1 & 43.4 & 53.9 & 0.0 & 0.0 & 21.1 & 39.7 &
35.2 & 49.4 & 57.3 & 62.1
DeepInteraction [21] & 57.9 & - & - & 68.8 & 71.3 & 46.5 & 54.9 & 0.0 & 0.0 & 21.4
& 39.9 & 41.7 & 53.2 & 59.9 & 64.0
GraphBEV [52] & 41.4 & - & - & 68.9 & 71.3 & 46.1 & 53.4 & 0.0 & 0.0 & 20.9 & 40.6 & 40.6
& 50.5 & 59.2 & 64.2
UniTR [29] & 12.2 & - & - & 70.2 & 72.1 & 46.8 & 56.5 & 0.1 & 0.8 & 21.7 & 41.1 & 39.3 & 55.1
& 62.4 & 66.1
SparseFusion [19] & 43.8 & - & - & 70.9 & 72.9 & 48.1 & 59.6 & 0.0 & 0.0 & 23.8 & 44.1
& 41.1 & 59.2 & 57.8 & 65.9
CMT [13] & 86.6 & 1.1 & - & 69.7 & 72.3 & 52.4 & 60.1 & 37.8 & 42.4 & 41.7 & 52.6 & 64.8 & 69.2
& 61.0 & 67.2
MoME [18] & 86.6+2.5 & 1.1 & 1.3 & 70.3 & 72.1 & 53.4 & 61.6 & 40.6 & 46.1 & 48.6 & 53.3 & 65.8 & 69.4 &
61.4 & 67.7
MEFormer [35] & 86.6+0.3 & 1.2 & 14.3 & 70.5 & 72.7 & 54.3 & 62.1 & 41.0 & 47.3 & 49.9 & 55.2
& 67.1 & 71.8 & 62.1 & 68.3
BEVFusion-MIT (MD) [2] & 40.8 & 1.4 & - & 56.1 & 62.2 & 18.1 & 31.3 & 12.1 & 14.4 & 11.8 & 15.2
& 22.5 & 26.6 & 44.1 & 50.1
UniBEV [17] & 40.8+31.9 & 1.2 & 1.1 & 63.2 & 66.9 & 45.3 & 52.7 & 33.5 & 40.2 & 38.9 & 48.1 &
57.2 & 64.3 & 57.1 & 63.2
MetaBEV \(^{\dagger}\) [16] & - & - & - & 68.0 & 71.5 & - & 57.7 & 39.0 &
42.6 & - & 47.0 & - & 67.6 & 63.6 & 69.2
GraphBEV [52] & 41.4 & 1.4 & - & 68.9 & 71.3 & 46.1 & 53.4 & 0.0 & 0.0 & 20.9 & 40.6 & 40.6
& 50.5 & 59.2 & 64.2
GraphBEV +Ours & 41.4+1.2 & 2.3 & 32.7 & 69.3 & 71.8 & 49.2 & 56.3 & 34.2 & 41.7 & 42.8 & 53.1 & 55.2 & 63.6 & 64.2 & 69.1
improvements & - & - & - & 0.4 & 0.5 & 3.1 & 2.9 & 34.2 & 41.7 & 21.9 & 12.5 & 14.6 & 13.1 & 5.0 & 4.9
BEVFusion-AD [3] & 90.2 & 0.6 & - & 68.1 & 70.1 & 43.4 & 53.9 & 0.0 & 0.0 & 21.1 & 39.7
& 35.2 & 49.4 & 57.3 & 62.1
BEVFusion-AD +Ours & 90.2+1.2 & 1.1 & 35.9 & 69.2 & 70.8 & 49.0 & 57.3 & 34.7 & 41.5 & 42.1 & 51.9 & 60.9 & 65.6 & 65.7 & 69.6
improvements & - & - & - & 1.1 & 0.7 & 5.6 & 3.4 & 34.7 & 41.5 & 21.0 & 12.2 & 25.7 & 16.2 & 8.4 & 7.5
BEVFusion-MIT [2] & 40.8 & 1.4 & - & 66.9 & 69.7 & 41.2 & 52.4 & 0.0 & 0.0 & 20.2 & 37.6 &
34.3 & 47.8 & 56.2 & 61.5
BEVFusion-MIT +Ours & 40.8+1.2 & 2.3 & 33.5 & 68.3 & 71.2 & 46.9 & 58.4 & 32.8 & 39.9 & 41.1 & 50.2 & 59.9 & 65.3 & 63.6 & 68.8
improvements & - & - & - & 1.4 & 1.5 & 5.7 & 6.0 & 32.8 & 39.9 & 20.9 & 12.6 & 25.6 & 17.5 & 7.4 & 7.3
The core premise of Grace-BEV is that blind trust in geometric priors leads to system collapse when sensors degrade. To address this, we present the TrustGate Router, a lightweight module designed to quantify the geometric integrity of the LiDAR stream in real-time.
Mechanism. As shown in 2, the router operates on the LiDAR BEV feature map \(F_{pts}^{voxel} \in \mathbb{R}^{C_{pts} \times H \times W}\), where \(C_{pts}\) denotes the channel dimension of the LiDAR backbone. Instead of employing heavy attention mechanisms, we leverage global statistical properties to detect sensor anomalies. More specifically, we employ dual adaptive pooling to aggregate element-wise statistics into a global descriptor \(s_{stat} \in \mathbb{R}^{2C}\): \[s_{stat} = \text{Concat}\left( \mathcal{P}_{avg}(F_{pts}^{voxel}), \mathcal{P}_{max}(F_{pts}^{voxel}) \right), \label{eq:pooling}\tag{1}\] where \(\mathcal{P}_{avg}\) and \(\mathcal{P}_{max}\) denote global adaptive average and max pooling, respectively. Such a treatment captures both the background signal intensity and salient geometric features. Subsequently, we employ a lightweight MLP with a bottleneck structure to map the statistics to a trust score: \[\alpha = \sigma \left( W_2 \cdot \delta ( W_1 \cdot s_{stat} ) \right). \label{eq:trust95score}\tag{2}\] Here, \(W_1 \in \mathbb{R}^{64 \times 2C}\) compresses the arbitrary input dimensions to a compact hidden space (fixed at 64 channels), \(\delta\) denotes the ReLU activation, and \(W_2 \in \mathbb{R}^{1 \times 64}\) maps the hidden features to a scalar. The final output \(\alpha\) is reshaped to \(\mathbb{R}^{B \times 1 \times 1 \times 1}\) for seamless broadcasting.
Routing Logic. The generated trust score \(\alpha \in [0, 1]\) serves as a sample-adaptive coefficient. We utilize \(\alpha\) to softly interpolate the BEV features from the two experts via element-wise broadcasting: \[F_{img}^{BEV} = \alpha \odot F_{\text{Expert A}}^{BEV} + (1 - \alpha) \odot F_{\text{Expert B}}^{BEV}, \label{eq:routing}\tag{3}\] where \(F_{\text{Expert A}}^{BEV}\) and \(F_{\text{Expert B}}^{BEV}\) denote the projected BEV feature representations generated by Expert A and Expert B, respectively. Under normal conditions (\(\alpha \to 1\)), the system prioritizes the precise geometric features from Expert A. Conversely, when LiDAR signals are corrupted (\(\alpha \to 0\)), the router automatically suppresses the noisy geometric branch and upweights the semantic features from Expert B, effectively reducing the structural reliance on the compromised modality.
Standard fusion approaches typically adopt a “concatenate-and-convolve” strategy. While effective under ideal conditions, this hard fusion creates a vulnerability: if the LiDAR backbone output \(F_{pts}^{voxel}\) becomes zero-filled due to sensor failure, the concatenated tensor undergoes a severe distribution shift, confusing subsequent layers.
To handle this, we propose the FFB, which introduces a learnable gating mechanism to dynamically recalibrate feature importance before integration.
Architecture. As illustrated in 2, the fusion block receives two inputs: the raw LiDAR BEV features \(F_{pts}^{voxel}\) (from the LiDAR backbone) and the robust synthesized image BEV features \(F_{img}^{BEV} \in \mathbb{R}^{C_{img} \times H \times W}\) (the output of Eq. 3 ). We first concatenate them to form a unified representation: \[F_{cat} = \text{Concat}(F_{pts}^{voxel}, F_{img}^{BEV}) \in \mathbb{R}^{(C_{pts}+C_{img}) \times H \times W}.\] Instead of fusing them directly, we employ a Gate Generator to predict an element-wise re-weighting map \(W_{gate}\) from this joint context: \[W_{gate} = \sigma \left( \mathcal{F}_{excite}( \mathcal{F}_{squeeze}(F_{cat}) ) \right). \label{eq:gate95gen}\tag{4}\] Here, the generator follows a lightweight bottleneck design (reduction ratio \(r=4\)). Specifically, \(\mathcal{F}_{excite}\) utilizes a dilated convolution (\(3 \times 3\), \(d=2\)) to enlarge the receptive field, leveraging spatial context to verify signal reliability.
Gated Integration. The learned gate \(W_{gate}\) acts as a soft mask to filter out noise or corrupted channels in the concatenated tensor: \[F_{fused}^{BEV} = \mathcal{F}_{align} \left( F_{cat} \odot W_{gate} \right), \label{eq:gated95fusion}\tag{5}\] where \(\odot\) denotes element-wise multiplication. If the LiDAR stream \(F_{pts}^{voxel}\) is corrupted (i.e., zero-filled), the Gate Generator—trained to recognize such sparsity patterns—will suppress the corresponding channels in \(W_{gate}\), allowing the robust features from \(F_{img}^{BEV}\) to dominate. Finally, \(\mathcal{F}_{align}\) projects the gated features to the target dimension required by the detection head. By initializing the final bias of the Gate Generator to 0 (yielding \(W_{gate} \approx 0.5\)), we ensure an unbiased starting point for stable training.
Training a robust MoE framework is non-trivial due to the “modality dominance” phenomenon [13], [53], [54], where the model tends to over-rely on the dominant modality (LiDAR) while ignoring the weaker one (Camera). To address this, we design a Three-Phase Training pipeline, as illustrated in 3.
Phase 1: Pure Vision Pre-training. Empirical observations indicate that initializing the system with a weak vision expert severely limits the lower bound of robustness. Therefore, in the first phase, we treat the model as a pure camera-based detector. We discard the LiDAR branch and initialize Expert B using a pre-trained camera-only model (specifically utilizing its LSS-based view transformer and backbone) [2], [3]. This strategy leverages established semantic representations and avoids the instability of training from scratch, providing a strong fallback foundation independent of geometric priors.
Phase 2: Router & Fusion Warm-up. In this phase, we freeze the pre-trained Image Backbone and Expert B to prevent feature forgetting (indicated by snowflakes in 3). We then introduce the pre-trained LiDAR branch (Expert A) and train the TrustGate Router and the FFB. Crucially, we employ an MD strategy to simulate diverse modality availability states. During each training iteration, the feature inputs to the experts and router are sampled from a mixed distribution: \[(\tilde{F}_{pts}, \tilde{F}_{img}) = \begin{cases} (F_{pts}^{voxel}, F_{img}^{2D}), & p=0.50 \\ (\mathbf{0}, F_{img}^{2D}), & p=0.25 \\ (F_{pts}^{voxel}, \mathbf{0}), & p=0.25 \end{cases},\] where \(\tilde{F}_{pts}\) and \(\tilde{F}_{img}\) denote the stochastic feature inputs fed into the subsequent modules [13]. This balanced dropout strategy serves a dual purpose. The LiDAR Failure case explicitly supervises the Router to output a low trust score (\(\alpha \to 0\)), forcing the system to rely on Expert B. Conversely, the Camera Failure case forces the fusion module to utilize geometric cues from Expert A, preventing the system from ignoring the newly arrived LiDAR branch in favor of the strong pre-trained vision expert.
Phase 3: End-to-End Fine-tuning. Finally, we unfreeze all components and perform end-to-end optimization with a reduced learning rate. This phase aligns the feature spaces of both experts and fine-tunes the router’s decision boundary for hard cases, ensuring global optimality for the entire framework.
Dataset and Metrics. For evaluation, we report the standard mAP and NuScenes Detection Score (NDS) [55]. To rigorously assess robustness, we conduct experiments on two challenging dataset variants: nuScenes-R [32] for sensor impairment simulation and nuScenes-C [33] for extreme weather conditions. Specifically, on nuScenes-R [32], we evaluate three categories of corruption: (1) LiDAR Failure, including complete sensor blackout (LiDAR Drop), partial view loss (Limited FOV), and beam reduction; (2) Camera Failure, simulating image blackout (View Drop); and (3) Object Failure, simulating reflection noise. Meanwhile, nuScenes-C [33] is used to verify generalization under physics-based weather corruptions, including fog, rain, and snow.
Architecture and Baselines. We select three SOTA frameworks as our primary baselines [2], [3], [52]. We re-implement and train all baseline methods in a unified experimental setting, except MetaBEV [16], for which we report results from the original paper due to the lack of public code. We integrate our TrustGate Router and FFB into these frameworks by replacing their original fusion layers, while keeping all other components unchanged.
Training Settings. All models are trained on 4\(\times\) NVIDIA A100 GPUs. We adopt the proposed Three-Phase Training strategy to ensure stable convergence. In Phase 1, the vision expert is initialized from a pre-trained camera-only checkpoint and warmed up for 1 epoch with a learning rate of \(1 \times 10^{-4}\). In Phase 2, we freeze both backbones and exclusively train the router and fusion modules for 3 epochs with a learning rate of \(1 \times 10^{-5}\). During this phase, we apply the MD strategy (\(p_{both}=0.5\), \(p_{L\text{-}drop}=0.25\), \(p_{C\text{-}drop}=0.25\)) to force the router to learn failure-aware policies. Finally, in Phase 3, we unfreeze all components and fine-tune the entire network end-to-end for another 3 epochs with a minimized learning rate of \(1 \times 10^{-7}\) [56], [57].
A comprehensive quantitative comparison is presented in [tab:main95results]. Grace-BEV achieves the best trade-off between robustness and efficiency. Robustness against Modality Failures. The most significant breakthrough is observed in the catastrophic LiDAR Drop scenario. While standard LSS-based detectors suffer a total collapse to 0.0% mAP, confirming the severe impact of modality dominance, Grace-BEV successfully recovers performance to 34.7% mAP. Beyond binary failures, our method also demonstrates universal resilience. In partial corruptions and camera-denied scenarios, Grace-BEV yields consistent gains of +3.1% \(\sim\) +25.7% mAP across all baselines, proving its ability to handle diverse noise distributions.
Efficiency and Clean Performance. Crucially, this robustness does not compromise standard capabilities. On the clean validation set, Grace-BEV improves the mAP of all baselines by +0.4% \(\sim\) +1.4%. Furthermore, compared to heavy Transformer-based approaches like CMT (MRE 1.1), our method functions as a lightweight plugin with a significantly higher Marginal Robustness Efficiency (MRE 35.9), delivering maximum robustness gains with minimal parameter overhead. Importantly, this minimal parameter addition introduces only negligible inference overhead. For example, on BEVFusion-MIT, the latency increases marginally from 40.76 ms to 40.81 ms on a single NVIDIA A100 GPU with 1 worker and batch size 1, thereby preserving the real-time processing capability of the original baseline.
4pt
| Method | Modality | Fog | Snow | Sunlight | Rainy | Night |
|---|---|---|---|---|---|---|
| DETR3D | C | 31.7 | 5.9 | 39.2 | 28.4 | 15.7 |
| CenterPoint | L | 43.7 | 55.9 | 57.4 | 55.2 | 36.2 |
| TransFusion | LC | 54.7 | 62.1 | 56.6 | 63.7 | 40.1 |
| DeepInteraction | LC | 55.2 | 62.0 | 65.1 | 69.9 | 43.9 |
| CMT | LC | 66.6 | 62.3 | 63.3 | 69.1 | 43.0 |
| UniTR | LC | 55.7 | 63.7 | 63.6 | 64.1 | 38.5 |
| BEVFusion-MIT | LC | 54.7 | 52.8 | 64.1 | 68.1 | 41.9 |
| + Ours | LC | 55.0 | 54.1 | 65.7 | 69.9 | 42.5 |
| BEVFusion-AD | LC | 55.3 | 53.9 | 64.8 | 68.4 | 43.7 |
| + Ours | LC | 55.5 | 55.2 | 65.6 | 70.7 | 44.1 |
| GraphBEV | LC | 54.8 | 53.1 | 64.0 | 70.0 | 44.9 |
| + Ours | LC | 55.8 | 53.8 | 64.6 | 70.2 | 45.2 |
To verify the generalization capability of Grace-BEV beyond discrete sensor failures, we evaluate it on nuScenes-R and nuScenes-C [32], [33]. Unlike simulated sensor drops, extreme weather introduces complex, continuous noise distributions that test the adaptability of the fusion module.
As shown in 1, Grace-BEV consistently improves performance across all conditions, effectively acting as a universal stabilizer against environmental domain shifts. Specifically, under LiDAR-degrading scenarios such as Rainy, our method achieves a substantial gain of +2.3% mAP (68.4% \(\to\) 70.7%) on BEVFusion-AD, proving its ability to mitigate signal attenuation. Similarly, in camera-compromising conditions such as Sunlight (strong glare), Grace-BEV boosts BEVFusion-MIT [3] by +1.6% mAP, demonstrating that the FFB effectively suppresses photometric noise. These results confirm that our active reliability awareness generalizes well to corruptions not explicitly seen during training.
In this section, we perform a comprehensive ablation analysis on the nuScenes validation set to verify the contribution of each proposed component and justify our design choices. The baseline is the standard BEVFusion-MIT model.
4pt
| Row | Components | Clean | L-Drop | C-Drop | ||||
|---|---|---|---|---|---|---|---|---|
| 2-3 (lr)4-5 (lr)6-7 (lr)8-9 | TG | FFB | mAP | NDS | mAP | NDS | mAP | NDS |
| 1 | - | - | 56.1 | 62.2 | 12.1 | 14.4 | 44.1 | 50.1 |
| 2 | ✔ | - | 67.2 | 69.9 | 28.5 | 35.2 | 56.0 | 61.3 |
| 3 | - | ✔ | 67.5 | 70.3 | 15.5 | 20.2 | 57.8 | 63.2 |
| 4 | ✔ | ✔ | 68.3 | 71.2 | 32.8 | 39.9 | 58.4 | 65.1 |
Impact of Key Components. We further examine the contributions of the TrustGate Router and the FFB under the default MD training setting, with results summarized in 2. Even when equipped with MD, the standard baseline remains fragile: although dropout is intended to improve robustness, the baseline achieves only 12.1% mAP under L-Drop and suffers a severe degradation in Clean performance, dropping from 66.9% to 56.1%, indicating that naive dropout training alone cannot effectively prevent modality imbalance. Introducing the TrustGate Router substantially improves robustness under L-Drop, raising mAP to 28.5% while preserving competitive Clean performance at 67.2% mAP. This result suggests that the router can explicitly regulate feature flow based on modality reliability, enabling the model to better benefit from dropout training without sacrificing normal-condition accuracy. Replacing standard concatenation with the FFB further enhances robustness under C-Drop, yielding a gain of 13.7% over the baseline, while also refining Clean performance. When combined together, the TrustGate Router and FFB produce the best overall trade-off between robustness and accuracy, achieving the strongest performance across all evaluated settings, including 68.3% mAP on Clean and 32.8% mAP under L-Drop.
| Fusion Strategy | Clean | L-Drop (Failure) | ||
|---|---|---|---|---|
| 2-3 (lr)4-5 | mAP | NDS | mAP | NDS |
| Concat (Baseline) | 66.9 | 69.7 | 0.0 | 0.0 |
| Addition | 65.5 | 68.2 | 12.5 | 20.1 |
| SE-Block (Channel Attn) | 67.3 | 70.1 | 5.2 | 8.5 |
| CBAM (Spatial+Channel) | 67.6 | 70.4 | 8.9 | 12.3 |
| FFB (Ours) | 68.3 | 71.2 | 32.8 | 39.9 |
Effectiveness of FailSafe Fusion. To demonstrate the superiority of our element-wise gating design, we compare FFB with other popular fusion mechanisms in 3. Simple operations like Addition fail to handle the feature scale mismatch between modalities. Attention-based methods like SE-Block (Channel Attention) and CBAM show limited robustness improvements (5.2% and 8.9% mAP on L-Drop) because they apply global or semi-global pooling, which cannot spatially isolate corrupted regions in the BEV map. In contrast, our FFB achieves 32.8% mAP, proving that pixel-wise (voxel-wise) re-weighting is essential for handling precise spatial corruptions in LiDAR-camera fusion.
| Router Input | Dim | mAP (Clean) | mAP (L-Drop) |
|---|---|---|---|
| Global AvgPool Only | \(C\) | 68.0 | 25.4 |
| Global MaxPool Only | \(C\) | 68.1 | 29.8 |
| Concat (Avg + Max) | \(2C\) | 68.3 | 32.8 |
Router Architecture Design. We investigate the input statistics used for the TrustGate Router in 4. Using only Average Pooling tends to smooth out local high-confidence features, while Max Pooling captures prominent features but may be sensitive to outliers. Concatenating both statistics allows the MLP to learn a more comprehensive representation of feature integrity, resulting in the highest robustness score.
4pt
| Dropout Config | Clean | L-Drop | C-Drop | ||||
|---|---|---|---|---|---|---|---|
| 1-2 (lr)3-4 (lr)5-6 (lr)7-8 \(p_{L\text{-}drop}\) | \(p_{C\text{-}drop}\) | mAP | NDS | mAP | NDS | mAP | NDS |
| 0.00 | 0.50 | 67.8 | 70.5 | 5.2 | 10.5 | 59.1 | 65.8 |
| 0.10 | 0.40 | 68.0 | 70.9 | 22.1 | 30.4 | 58.8 | 65.4 |
| 0.25 | 0.25 | 68.3 | 71.2 | 32.8 | 39.9 | 58.4 | 65.1 |
| 0.40 | 0.10 | 68.1 | 71.0 | 31.5 | 39.1 | 45.2 | 55.3 |
| 0.50 | 0.00 | 67.5 | 70.1 | 32.0 | 39.5 | 30.1 | 42.5 |
Sensitivity to Dropout Probabilities. Finally, we analyze the impact of the MD distribution in 5. We fix the full-modality training probability \(p_{both}=0.5\) and vary the allocation of failure simulation. An imbalanced distribution leads to biased robustness. For instance, setting \(p_{L\text{-}drop}=0\) (never training on pure vision) results in a failure to generalize to LiDAR blackouts (5.2% mAP). Our balanced strategy (0.25/0.25) provides a favorable trade-off between clean accuracy and dual-modality robustness.
Qualitative Results. 4 presents qualitative results comparing our proposed Grace-BEV with the baseline BEVFusion-MIT across various sensor failure scenarios. While the baseline is significantly impacted by modality failures, leading to severe missed detections, Grace-BEV achieves consistently robust detection by effectively routing to the reliable modality, demonstrating the advantages of our active reliability awareness.
In this work, we revisit a fundamental yet underexplored question in multi-modal BEV perception: whether high-performance detectors can degrade gracefully under missing or corrupted modalities. Through systematic analysis, we show that existing fusion frameworks suffer from catastrophic collapse due to their modality dominance and static cross-modal integration. To address this limitation, we propose Grace-BEV, a lightweight and plug-and-play framework that introduces active reliability awareness into LSS-based architectures. By explicitly assessing modality trustworthiness via the TrustGate Router and dynamically recalibrating feature interaction through the FFB, Grace-BEV enables robust and predictable degradation without resorting to heavy redundant decoders. Extensive experiments on nuScenes-R and nuScenes-C demonstrate that our approach consistently restores vision-only functionality under severe LiDAR failures while improving clean performance with minimal overhead. We believe this work highlights the importance of active modality reliability assessment for reliable multi-modal perception and provides a practical foundation for future robustness-oriented BEV systems.
This work was supported in part by the National Natural Science Foundation of China under Grants 62403348 and 62403350; in part by the Postdoctoral Fellowship Program of CPSF under Grants GZC20241208 and 2024M762357; in part by the Foundation of Key Laboratory of System Control and Information Processing, Ministry of Education, P.R. China, under Grant Scip20240116; and in part by the Emerging Frontiers Cultivation Program of Tianjin University Interdisciplinary Center.