SMG-UAV: Sparse Mutual Guided RGB–Event Fusion for Robust UAV Detection in Challenging Dynamic Environments

Highlights

What are the main findings?

• A sparse mutual guided RGB–event fusion network, SMG-UAV, is proposed with a modality-specific hybrid CSP backbone, SMG-Bridge, and SGP-Neck, enabling bidirectional reliability-aware compensation between dense RGB appearance cues and sparse event-driven motion cues for robust small-UAV detection in challenging dynamic environments.
• SMG-UAV achieves state-of-the-art performance on FRED and NeRDD, while consistently obtaining the best results on small-target, motion-blur, extreme-illumination, background-embedded, and bird distractor subsets.

What are the implications of the main findings?

• This work demonstrates that event cameras and reliability-aware RGB–event fusion can substantially improve practical low-altitude anti-UAV surveillance when RGB imagery is degraded by illumination variation, motion blur, cluttered backgrounds, or tiny target scale.
• The proposed method provides an effective solution for multimodal small-object detection by combining sparse cross-modal recovery, unreliable response suppression, and selective multiscale enhancement, supporting applications such as airport protection, perimeter defense, critical-infrastructure monitoring, and public-event security.

Abstract

Robust unmanned aerial vehicle (UAV) detection in real low-altitude anti-UAV scenarios remains challenging due to motion blur, extreme illumination, cluttered backgrounds, and tiny target sizes. Most existing UAV detectors rely on RGB imagery, but their performance often degrades severely under these adverse conditions. Event cameras, as a neuromorphic sensing modality, capture motion-sensitive responses with high temporal resolution and thus provide complementary cues for robust UAV detection. However, existing RGB–event fusion detectors usually employ homogeneous feature extraction and generic fusion mechanisms, which are insufficient to handle heterogeneous modality degradation and exploit reliable cross-modal cues. To address this limitation, we propose SMG-UAV, a sparse mutual guided RGB–event fusion network for robust small-UAV detection. The proposed method integrates a hybrid dual-branch backbone for modality-specific representation learning, a Sparse Mutual Guided Bridge for bidirectional sparse cross-modal refinement, and a Selective Gated Pyramid Neck for multiscale enhancement of weak UAV responses. Experiments on the Florence RGB-Event Drone Dataset (FRED) and the Neuromorphic-RGB Drone Detection Dataset (NeRDD) demonstrate that SMG-UAV achieves state-of-the-art performance, outperforming the strongest competing method by an average of 5.2 points in ${\mathrm{AP}}_{50}$, while delivering stronger robustness under multiple challenging anti-UAV conditions.

1. Introduction

The rapid development of unmanned aerial vehicles (UAVs) has brought significant benefits to aerial sensing, logistics, emergency response, infrastructure inspection, and environmental monitoring [1,2,3]. However, unauthorized or malicious UAVs may also pose potential threats to low-altitude airspace safety, airport operation, public-event security, critical infrastructure protection, and personal privacy [4,5,6]. Therefore, accurate and robust detection of UAVs has become a fundamental requirement for anti-UAV surveillance systems [7,8,9]. Reliable UAV detection not only provides the spatial localization of suspicious aerial targets, but also serves as the front-end basis for subsequent identification, tracking, risk assessment, and interception decisions.

Although deep learning-based UAV detection methods have achieved notable progress, most existing approaches still rely primarily on RGB visible-light images as the main sensing input. This RGB-centric detection paradigm benefits from dense texture, color, and semantic information, and has shown strong performance under well-illuminated and relatively clean imaging conditions. However, its robustness remains insufficient for real-world low-altitude anti-UAV surveillance. Small UAVs observed at long ranges often occupy only a few pixels, producing weak appearance cues and ambiguous object boundaries. Meanwhile, rapid UAV motion, camera ego-motion, low illumination, overexposure, and illumination variation can degrade RGB frames and cause motion blur, unstable target appearance, or partial loss of visual details. In addition, complex low-altitude backgrounds, such as clouds, tree branches, buildings, and power lines, often reduce the visual saliency of small UAVs, making their weak RGB appearance cues easily overwhelmed by surrounding background structures. As a result, conventional RGB-based detectors may struggle to reliably localize small UAVs in complex and dynamic environments.

Event cameras provide a promising complementary sensing modality for this task. Different from conventional RGB cameras that record dense intensity frames at a fixed frame rate, event cameras asynchronously respond to brightness changes with microsecond-level latency, high dynamic range, and sparse motion-sensitive outputs [10]. As a result, event streams can preserve sharp motion contours under fast motion and extreme illumination, while RGB frames provide dense appearance, texture, color, and semantic context [11,12]. Figure 1 shows representative RGB frames and event data under different challenging conditions. The complementary characteristics of RGB and event data make RGB–event sensor fusion an attractive solution for robust object detection in challenging dynamic environments [12,13,14,15]. Accordingly, RGB–event fusion has recently become a promising research direction in anti-UAV perception, as it offers the potential to improve detection robustness and localization reliability under complex low-altitude conditions [16,17,18].

Despite its potential, current RGB–event detection frameworks still have several limitations when applied to UAV detection in low-altitude anti-UAV scenarios. One important issue is the treatment of modality heterogeneity. Existing methods often use similar backbone networks for RGB frames and event representations, which simplifies the architecture but ignores the different sensing principles of the two modalities [12,13,14]. RGB images provide dense texture, color, and semantic context, whereas event streams respond sparsely to temporal brightness changes and contain motion-sensitive boundary information [10,11]. A homogeneous backbone design may therefore fail to fully exploit the sparse and dynamic nature of event data.

The fusion stage also remains insufficiently explored. Most existing methods combine RGB and event features through concatenation, summation, channel weighting, or generic attention [12,13,14,15]. While these operations are effective for feature aggregation, they provide limited insight into how complementary information is recovered under modality-specific degradation. In real anti-UAV scenarios, the reliability of RGB and event data changes with illumination, target motion, background dynamics, and imaging distance [17,18]. RGB features may be corrupted by blur or exposure changes, whereas event responses may be sparse for weak motion or contaminated by background activity. This suggests that RGB–event fusion should explicitly consider cross-modal compensation and reliability-aware selection rather than only feature-level aggregation.

Small UAV targets further increase the difficulty of feature representation. In long-range surveillance, they often appear as tiny, low-contrast objects with limited texture, and their responses can be easily weakened during hierarchical feature extraction [6,19,20]. Although feature pyramid networks are widely used for multiscale detection [21], generic pyramid aggregation does not necessarily strengthen small and weak UAV cues. High-level features are semantically informative but spatially coarse, while low-level features preserve location details but are sensitive to clutter. A dedicated multiscale enhancement design is therefore necessary to propagate useful semantic and localization information across scales and improve the robustness of small UAV localization.

To address the above challenges, we propose SMG-UAV, an RGB–event fusion framework for robust small UAV detection in challenging low-altitude environments. SMG-UAV follows a modality-aware and task-oriented design. For feature extraction, an appearance-oriented CSPDarknet [22] is adopted for RGB frames, while an improved Spiking CSPDarknet is developed to efficiently capture sparse event-driven motion features from event voxels. To achieve reliable cross-modal compensation under asymmetric modality degradation, we design Sparse Mutual Guided Bridge (SMG-Bridge) to perform sparse mutual guidance and reliability-aware feature interaction between RGB and event features. This module encourages reliable cues from one modality to complement degraded or ambiguous responses in the other. To enhance weak small-UAV responses during multiscale feature aggregation, we further construct Selective Gated Pyramid Neck (SGP-Neck), which progressively propagates semantic and spatial cues across scales to preserve localization-sensitive information and strengthen small-target representations.

The main contributions of this work are summarized as follows:

• We propose SMG-UAV, a dedicated RGB–event small UAV detection framework for low-altitude anti-UAV surveillance. The framework exploits the complementary sensing properties of RGB frames and event streams to improve robustness under motion blur, illumination degradation, complex backgrounds, and weak small-target conditions.
• We develop three task-oriented modules for robust RGB–event UAV detection: an improved Spiking CSPDarknet for efficient sparse event feature extraction, SMG-Bridge for sparse mutual guided and reliability-aware cross-modal interaction, and SGP-Neck for progressive multiscale enhancement of weak small-UAV responses.
• Extensive experiments on RGB–event UAV detection benchmarks demonstrate the effectiveness of the proposed method in terms of detection accuracy and robustness compared with RGB-only, event-only, and existing RGB–event fusion detectors.

2. Related Work

2.1. Vision-Based UAV Detection

Vision-based UAV detection has attracted increasing attention in low-altitude surveillance, airport protection, and anti-UAV security systems. Early methods mainly relied on handcrafted appearance features, background modeling, motion cues, or trajectory filtering to distinguish UAV targets from sky or ground backgrounds [19,20,23]. With the development of deep learning, CNN-based and transformer-based object detectors have become the dominant solutions for UAV detection. One-stage detectors, represented by the YOLO family [24], are widely used due to their favorable balance between accuracy and inference speed, while two-stage and DETR-style detectors provide stronger feature modeling and localization capability in complex scenes [25,26].

However, UAV detection is still more difficult than generic object detection. UAVs observed from long distances usually occupy only a small number of pixels and show weak texture, low contrast, and ambiguous boundaries. To address these issues, recent studies have introduced small target feature extraction, multiscale attention, high-resolution detection heads, context-enhanced feature pyramids, and refined localization modules [27,28,29,30]. These methods improve scale adaptation and localization to some extent, but most of them still rely on RGB visible-light images. When RGB frames are affected by motion blur, low illumination, overexposure, or complex low-altitude backgrounds, the appearance cues of small UAVs can be severely degraded. This limitation motivates the use of complementary sensing modalities to improve detection robustness under challenging dynamic conditions.

2.2. RGB–Event Fusion Object Detection

Event cameras provide an alternative sensing paradigm for dynamic visual perception. Unlike frame-based cameras that record dense images at a fixed frame rate, event cameras asynchronously respond to pixel-level brightness changes and generate sparse event streams with high temporal resolution, high dynamic range, and low latency. These properties make event cameras suitable for challenging scenarios involving fast motion, illumination variation, and high-speed targets [10]. Since raw events are asynchronous and sparse, they are usually transformed into event frames, time surfaces, voxel grids, or other spatio-temporal representations for deep network processing [11,31].

RGB–event object detection aims to combine dense appearance cues from RGB frames with motion-sensitive information from event streams. Existing methods generally adopt early fusion, late fusion, or intermediate fusion strategies. Early fusion directly stacks RGB and event representations at the input level, late fusion combines predictions from independent branches, and intermediate fusion performs feature-level interaction inside the network [32,33,34,35,36,37,38]. Recent studies have explored multi-level feature fusion, gated interaction, temporal aggregation, cross-modal attention, and transformer-based fusion for RGB–event detection [12,13,14,15]. These methods demonstrate the effectiveness of event cameras in improving perception robustness under adverse illumination and dynamic conditions.

However, existing RGB–event detection frameworks still have several limitations when applied to small UAV detection. Many methods convert events into frame-like representations and process them with ordinary CNN or transformer backbones, which may weaken the sparse and temporal characteristics of event data. In addition, most fusion modules are mainly designed as generic feature aggregation operations, with limited consideration of modality-specific degradation and reliability variation. This limitation becomes more critical in low-altitude anti-UAV scenarios, where RGB cues may be degraded by motion blur, low illumination, or overexposure, while event responses may become sparse under weak UAV motion or noisy under strong background activity. Therefore, robust RGB–event UAV detection requires both event-oriented feature extraction and reliability-aware cross-modal interaction.

2.3. Cross-Modal Fusion and Sparse Representation

Cross-modal fusion is a key issue in RGB–event detection, because the two modalities provide complementary but heterogeneous visual cues. RGB frames contain dense texture, color, and semantic information, whereas event streams mainly encode sparse brightness changes and motion-sensitive structures. Existing RGB–event detectors have introduced multi-level feature fusion, gated interaction, asynchronous attention, and transformer-based modeling to integrate the two modalities [13,14,15]. These designs improve the utilization of complementary RGB and event information, especially under adverse illumination or fast-motion conditions.

However, most fusion modules still perform feature aggregation in a largely data-driven manner. Simple operations such as concatenation, summation, and channel weighting are easy to implement, but they provide limited control over modality-specific noise and unreliable responses. Attention-based and transformer-based modules can model long-range or cross-modal dependencies, but they do not explicitly describe how degraded information in one modality is compensated by reliable cues from the other. This limitation becomes more critical in anti-UAV scenarios, where the reliability of RGB and event data varies with illumination, target motion, imaging distance, and background dynamics. Therefore, robust RGB–event fusion requires not only cross-modal interaction, but also reliability-aware selection and degradation compensation.

Sparse representation provides a useful perspective for designing more interpretable fusion mechanisms. It assumes that signals can be represented by a small number of informative bases or atoms, and has been widely used in image restoration, multifocus image fusion, multimodal image fusion, and multi-sensor image fusion [39,40,41,42]. Compared with unconstrained feature mixing, sparse representation encourages compact and informative responses, which is consistent with the sparse and noise-sensitive characteristics of event data.

Deep unfolding further bridges model-based optimization and learnable neural networks. By mapping iterative optimization procedures into network stages, unfolding-based methods retain the interpretability of optimization models while benefiting from data-driven parameter learning [43,44,45]. The iterative shrinkage-thresholding algorithm (ISTA), for example, alternates between reconstruction-oriented updates and sparsity-inducing shrinkage operations. Such a structure is suitable for modeling sparse feature recovery and suppressing redundant responses. Nevertheless, sparse and unfolding-inspired mechanisms have not been sufficiently explored for RGB–event UAV detection, particularly for modeling mutual compensation between degraded RGB appearance cues and event-driven motion structures. This motivates the proposed SMG-Bridge, which performs sparse mutual guidance and reliability-aware feature interaction for robust small UAV detection.

2.4. Comparative Summary and Research Gap

RGB-based UAV detectors benefit from mature image-based architectures and strong appearance modeling, and are commonly evaluated by AP, mAP, ${\mathrm{AP}}_{50}$, or ${\mathrm{AP}}_{75}$. However, they are vulnerable to motion blur, extreme illumination, background clutter, and tiny-target degradation. Moreover, many studies do not fully analyze recall, false alarms, inference speed, hardware requirements, or deployment constraints.

Event-based detectors provide high-temporal-resolution motion cues and stronger robustness to illumination changes. However, event-only representations may be disturbed by background-triggered events or become weak when the relative motion between the UAV and the sensor is limited.

RGB–event fusion methods aim to combine RGB semantic cues with event-based motion responses. Most existing strategies improve multimodal representation, but they still rely mainly on direct concatenation or feature reweighting and do not explicitly model asymmetric modality degradation. In practical anti-UAV scenes, RGB features may be unreliable under visual degradation, while event features may be noisy due to camera jitter, moving backgrounds, or non-target motion.

It should also be noted that existing UAV detection, event-based detection, and RGB–event fusion studies are often evaluated on different datasets, object categories, input resolutions, event representations, and hardware platforms. Therefore, directly comparing reported AP, recall, F1-score, FPS, or latency values across different papers may be unfair or misleading. For this reason, we provide direct quantitative comparisons under a unified experimental protocol in the Experiments section, and further report practical metrics including precision, recall, F1-score, false positives per frame, miss rate, inference latency, and computational complexity.

The research gap addressed in this paper is how to selectively exploit reliable cross-modal cues while suppressing unreliable modality-specific responses for robust small-UAV detection. To this end, SMG-UAV introduces a Sparse Mutual Guided Bridge that performs bidirectional sparse cross-modal refinement in a compact latent space, rather than simple feature aggregation. The proposed adaptive sparse updating allows reliable cues from one modality to guide the other modality and suppresses weak, noisy, or redundant responses. In addition, the Selective Gated Pyramid Neck enhances weak multiscale UAV responses, which is important for tiny and distant UAV targets in low-altitude surveillance.

3. Method

3.1. Problem Formulation and Overall Architecture

Given an RGB frame $R_t\in {\mathbb{R}}^{3\times H\times W}$ captured at time t and the corresponding event observations within a temporal window $\Delta t$, the goal of RGB–event small-UAV detection is to localize UAV targets by jointly exploiting appearance information from RGB imagery and motion-sensitive responses from event data.

The event set collected within the temporal window $\Delta t$ is defined as

$${\mathcal{E}}_t={\{e_k\mid t_k\in [t-\Delta t,t]\}}_{k=1}^n,$$

(1)

where t is the timestamp of the RGB frame $R_t$, $\Delta t$ is the event accumulation window, and n is the number of events collected in this window. In our implementation, $\Delta t$ is set according to the RGB frame interval so that the event observations are temporally paired with the corresponding RGB frame.

Each raw event in ${\mathcal{E}}_t$ is represented as

$$e_k=(x_k,y_k,t_k,p_k),k=1,\dots ,n,$$

(2)

where $(x_k,y_k)$ denotes the pixel coordinate of the k-th event, with $x_k\in \{0,\dots ,W-1\}$ and $y_k\in \{0,\dots ,H-1\}$, $t_k$ is the timestamp, and $p_k\in \{-1,+1\}$ is the polarity of the brightness change. Specifically, $p_k=+1$ and $p_k=-1$ indicate positive and negative log-intensity changes, respectively. Zero is not used as the polarity value of a raw event. Zero values may only appear in the accumulated event representation, such as event frames or event voxels, at spatial–temporal locations where no event is observed.

The event set is converted into an event voxel representation:

$$V_t\in {\mathbb{R}}^{2T\times H\times W},$$

(3)

where H and W denote the height and width of the input representation, respectively. T is the number of temporal bins, and the factor 2 corresponds to the positive and negative polarity channels.

Given the paired RGB frame and event voxel, the detector predicts a set of UAV instances:

$${\mathcal{Y}}_t=\mathcal{F}(R_t,V_t;\Theta )={\left\{(b_i,c_i,s_i)\right\}}_{i=1}^{N_t},$$

(4)

where $\mathcal{F}(·;\Theta )$ denotes the proposed SMG-UAV detector parameterized by $\Theta$, $R_t$ is the RGB frame, and $V_t$ is the paired event voxel representation. $N_t$ denotes the number of detected UAV instances in frame t. For the i-th detection, $b_i=(x_i,y_i,w_i,h_i)$ is the predicted bounding box, $c_i$ is the predicted class label, and $s_i$ is the final detection confidence score after post-processing.

The overall architecture of the proposed SMG-UAV is illustrated in Figure 2. The framework consists of a modality-specific hybrid CSP backbone, three SMG-Bridge, a SGP-Neck, and a YOLO-style detection head. The RGB branch extracts dense appearance and semantic features, while the event branch first converts asynchronous events into a voxel representation and then uses Spiking Conv blocks with LIF activations to encode sparse temporal motion cues. The multilevel RGB and event features are connected by SMG-Bridge at stages 3–5. After sparse mutual guidance, the fused features $\{F_f^3,F_f^4,F_f^5\}$ are passed to SGP-Neck, which outputs pyramid features $\{F_P^3,F_P^4,F_P^5\}$ for multiscale detection. Finally, the detection head predicts UAV bounding boxes, confidence scores, and class labels from these pyramid features.

For the fusion stages, the overall process can be summarized as

$$F_f^l=\mathrm{SMG}\text{-}\mathrm{Bridge}(F_R^l,F_E^l),l\in \{3,4,5\},$$

(5)

$$\{F_P^3,F_P^4,F_P^5\}=\mathrm{SGP}\text{-}\mathrm{Neck}(F_f^3,F_f^4,F_f^5),$$

(6)

where $\mathrm{SMG}\text{-}\mathrm{Bridge}(·)$ denotes the proposed Sparse Mutual Guided Bridge, which is used to perform bidirectional sparse cross-modal refinement between RGB and event features; $\mathrm{SGP}\text{-}\mathrm{Neck}(·)$ denotes the proposed Selective Gated Pyramid Neck, which takes the fused multiscale features as input and produces enhanced pyramid features for the subsequent detection head; $F_R^l$ and $F_E^l$ denote the RGB and event features at the l-th stage, respectively; $F_f^l$ denotes the fused feature produced by SMG-Bridge; and $\{F_P^3,F_P^4,F_P^5\}$ denote the enhanced pyramid features used for final prediction.

In this way, SMG-UAV forms a unified RGB–event detection framework that integrates modality-specific representation learning, sparse cross-modal fusion, and multiscale feature enhancement for robust small-UAV detection in challenging environments.

3.2. Modality-Specific Hybrid CSP Backbone

RGB frames and event streams are generated by fundamentally different sensing mechanisms, and therefore may not be optimally encoded by an identical feature extraction strategy. RGB imagery provides dense appearance information, including texture, color, and semantic context, whereas event data mainly capture sparse brightness variations with high temporal sensitivity and motion-aware structural responses. To better match these modality-specific characteristics, SMG-UAV adopts a hybrid CSP-based backbone, where the RGB branch is implemented with an appearance-oriented CSPDarknet and the event branch is constructed as an event-oriented Spiking CSPDarknet.

Given an RGB frame $R_t$, the RGB branch extracts hierarchical appearance representations through a standard CSPDarknet encoder:

$$\{F_R^1,F_R^2,F_R^3,F_R^4,F_R^5\}={\Phi }_R\left(R_t\right),$$

(7)

where $F_R^l\in {\mathbb{R}}^{C_l\times H_l\times W_l}$ denotes the RGB feature at stage l, and ${\Phi }_R(·)$ denotes the RGB backbone for extracting hierarchical appearance and semantic features from the input RGB frame $R_t$. Among them, the last three stages $\{F_R^3,F_R^4,F_R^5\}$ are used for subsequent cross-modal fusion, corresponding to spatial resolutions of approximately $1/8$, $1/16$, and $1/32$ of the input size, respectively. CSPDarknet is adopted in the RGB branch because cross-stage partial backbones have been widely validated in recent detection studies, including UAV and small-object detection tasks, showing reliable hierarchical feature extraction capability with favorable efficiency [46,47,48].

For the event modality, directly applying a conventional frame-based backbone to event voxels is suboptimal, since it may weaken the sparse and temporally sensitive nature of event signals. To address this issue, we construct the event encoder by adapting CSPDarknet into a spiking counterpart, termed Spiking CSPDarknet, in which the nonlinear activations in the event branch are replaced by spike-based neuronal dynamics. The event voxel $V_t$ is first discretized into multiple temporal bins, which are processed as sequential inputs to the spiking encoder. The resulting spiking responses are then temporally aggregated to obtain stage-wise event features $F_E^l$. The event voxel $V_t$ is encoded as

$$\{F_E^1,F_E^2,F_E^3,F_E^4,F_E^5\}={\Phi }_E\left(V_t\right),$$

(8)

where $F_E^l\in {\mathbb{R}}^{C_l\times H_l\times W_l}$ denotes the event feature at stage l, and ${\Phi }_E(·)$ denotes the event backbone for extracting hierarchical motion-sensitive features from the event voxel representation $V_t$. Similar to the RGB branch, the last three stages $\{F_E^3,F_E^4,F_E^5\}$ are used for multiscale cross-modal interaction. Maintaining the same stage hierarchy in both branches facilitates feature pairing and fusion at aligned spatial scales.

In the spiking event branch, we model the feature response at temporal step $\tau$ using the leaky integrate-and-fire (LIF) neuron model, following the LIF-neuron-based spiking modeling in [49,50]. Here, each spatial channel unit in the event feature map is treated as a spiking neuron, and its membrane potential represents the temporally accumulated activation state driven by event-based inputs. This design is suitable for event data because event responses are sparse and temporally asynchronous, while LIF neurons can naturally integrate temporal motion cues and generate sparse spike activations. The membrane potential is updated as

$$U^{\tau }=\lambda U^{\tau -1}(1-S^{\tau -1})+X^{\tau },$$

(9)

where $U^{\tau }$ denotes the membrane potential, $X^{\tau }$ is the input current, $\lambda$ is the decay factor, and $S^{\tau -1}$ denotes the spike state at the previous step. The term $(1-S^{\tau -1})$ implements the reset-after-spike mechanism, which reduces the accumulated membrane potential after a neuron fires. The spike output is generated by

$$S^{\tau }=\mathcal{H}(U^{\tau }-\theta ),$$

(10)

where $\theta$ is the firing threshold and $\mathcal{H}(·)$ denotes the Heaviside step function. In our implementation, the firing threshold $\theta$ is fixed to 1.0 for all LIF neurons and is not learned during training. This fixed-threshold setting avoids introducing additional neuron-specific parameters and makes the spiking event branch easier to reproduce. Since the Heaviside step function $\mathcal{H}(·)$ is non-differentiable, direct backpropagation through Equation (10) is not feasible. Therefore, we adopt surrogate gradient learning to train the spiking event branch. During the forward pass, the hard threshold function $\mathcal{H}(·)$ is used to generate binary spike outputs. During the backward pass, its derivative is approximated by a differentiable surrogate function. Specifically, we use the sigmoid surrogate function

$${\sigma }_{\alpha }\left(x\right)={\displaystyle \frac{1}{1+exp(-\alpha x)}},$$

(11)

and approximate the gradient of the spike function as

$${\displaystyle \frac{\partial S^{\tau }}{\partial U^{\tau }}}\approx \alpha {\sigma }_{\alpha }(U^{\tau }-\theta )\left[1-{\sigma }_{\alpha }(U^{\tau }-\theta )\right],$$

(12)

where $\alpha$ controls the smoothness of the surrogate gradient. In this way, gradients can be propagated through the non-differentiable spike function, while the forward computation still preserves binary spike activations. With this design, the event branch preserves the hierarchical representation capability of CSPDarknet while better matching the sparse activation pattern and temporal response characteristics of event data.

The modality-specific backbone therefore produces paired multiscale representations $\{F_R^3,F_R^4,F_R^5\}$ and $\{F_E^3,F_E^4,F_E^5\}$ for the subsequent SMG-Bridge, where cross-modal interaction is performed at aligned semantic scales.

3.3. Sparse Mutual Guided Bridge

After modality-specific feature extraction, RGB and event features provide complementary yet unevenly reliable cues. RGB features preserve dense appearance and semantic context, but they are easily degraded by motion blur, underexposure, overexposure, and cluttered backgrounds. Event features are more sensitive to motion boundaries and temporal structure, yet they may also contain background-triggered responses or become weak when UAV motion is subtle. Therefore, directly concatenating the two modalities may inject unreliable responses into the fused representation. To address this issue, we propose the Sparse Mutual Guided Bridge, which performs bidirectional cross-modal refinement in a compact sparse latent space and progressively propagates sparse guidance across feature levels.

The design of SMG-Bridge is inspired by sparse-coding and ISTA-style feature adaptation, where a high-dimensional feature can be represented by a compact sparse latent code and refined through residual correction [43,44,45]. Different from direct feature concatenation or ordinary gated fusion, we do not assume that RGB and event features are always equally reliable or directly interchangeable. Instead, we use sparse latent codes as compact guidance carriers. At each bridge stage, the current RGB or event feature is regarded as an observation anchor, while the propagated sparse code from the other modality provides cross-modal guidance for residual sparse updating.

In SMG-Bridge, reliability is not estimated by an additional manually designed confidence score. Instead, it is implicitly modeled through two learnable sparse updating mechanisms: the cross-modal guidance gate and the adaptive sparse threshold. The reconstruction residual measures the mismatch between the current feature and the feature reconstructed from its sparse code. The cross-modal guidance gate controls how the propagated sparse code from one modality modulates the direction and magnitude of the residual correction of the other modality, while the adaptive sparse threshold suppresses weak, noisy, or redundant latent responses through soft shrinkage. Therefore, reliable cross-modal cues are selectively propagated, whereas unreliable modality-specific responses caused by visual degradation, background-triggered events, or clutter are suppressed.

This mechanism differs from ordinary gated fusion. Conventional gated fusion usually concatenates dense RGB and event features or reweights them using scalar, channel-wise, or spatial attention weights. In contrast, SMG-Bridge first represents each modality in a compact sparse latent space, performs cross-modal residual correction under the guidance of the opposite modality, applies adaptive sparse shrinkage, and then reconstructs the enhanced modality-specific features for final fusion. Thus, SMG-Bridge is closer to an unfolding-inspired sparse refinement process than to direct feature aggregation.

Let $\{F_R^2,F_R^3,F_R^4,F_R^5\}$ and $\{F_E^2,F_E^3,F_E^4,F_E^5\}$ denote the RGB and event features extracted from the two backbone branches. For notational simplicity, each feature map at stage l is flattened along the spatial dimension and represented as

$$F_R^l,F_E^l\in {\mathbb{R}}^{B\times N_l\times C_l},$$

(13)

where B is the batch size, $N_l=H_l{W}_l$ is the number of spatial tokens, and $C_l$ is the channel dimension at stage l. Instead of independently re-initializing sparse representations at every fusion level, SMG-Bridge initializes the sparse latent codes only once from the stage-2 features and then progressively propagates them through stages 3–5:

$$I_2=P_0^I\left(F_R^2\right),E_2=P_0^E\left(F_E^2\right),$$

(14)

where $P_0^I(·)$ and $P_0^E(·)$ are lightweight initialization projections.

The propagated sparse latent codes are denoted as

$$I_l,E_l\in {\mathbb{R}}^{B\times N_l\times d_l},$$

(15)

where $N_l$ denotes the number of spatial tokens and $d_l$ is the latent dimension at stage l.

Before the propagated sparse codes are used at the next bridge, they are aligned to the current feature stage:

$${\widehat{I}}_{l-1}^l={\mathcal{A}}_I^l\left(I_{l-1}\right),{\widehat{E}}_{l-1}^l={\mathcal{A}}_E^l\left(E_{l-1}\right),{\widehat{I}}_{l-1}^l,{\widehat{E}}_{l-1}^l\in {\mathbb{R}}^{B\times N_l\times d_l},$$

(16)

where ${\mathcal{A}}_I^l(·)$ and ${\mathcal{A}}_E^l(·)$ denote lightweight cross-stage alignment operations that match both the token number and latent dimension of the current stage.

Specifically, the sparse token sequences propagated from stage $l-1$ are first rearranged according to their original two-dimensional spatial layouts. The resulting feature maps are resized to the spatial resolution of stage l and are subsequently flattened back into token sequences, so that their token number changes from $N_{l-1}$ to $N_l$. A modality-specific linear projection is then applied along the last dimension to transform the latent dimension from $d_{l-1}$ to $d_l$. The RGB and event alignment operations follow the same processing structure but use independent learnable parameters, allowing modality-specific sparse information to be preserved during cross-stage propagation. After these operations, the propagated sparse codes have the same token number and latent dimension as the sparse representations generated at the current bridge and can therefore participate directly in the subsequent guidance and reconstruction operations.

For simplicity, we omit the superscript of the aligned sparse codes in the following equations and still denote them as $I_{l-1}$ and $E_{l-1}$. As illustrated in Figure 3, each bridge consists of three steps. Figure 3a corresponds to event-guided RGB sparse updating, where the propagated event sparse code acts as a latent guidance carrier to correct the current RGB feature. Figure 3b corresponds to RGB-guided event sparse updating, where the propagated RGB sparse code provides semantic guidance to refine the current event feature. Figure 3c corresponds to final feature fusion, where the enhanced RGB and event features are adaptively reweighted and further refined to generate the fused output.

3.3.1. Event-Guided RGB Sparse Updating

At the l-th bridge, the propagated event sparse code $E_{l-1}$ is first transformed into a latent guidance gate:

$${\Gamma }_{E\to I}^l=tanh\left({Gate}_{E\to I}^l\left(E_{l-1}\right)\right),{\Gamma }_{E\to I}^l\in {\mathbb{R}}^{B\times N_l\times d_l},$$

(17)

where ${Gate}_{E\to I}^l(·)$ is implemented as a token-wise single linear layer applied in the low-dimensional sparse latent space:

$${Gate}_{E\to I}^l\left(E_{l-1}\right)=E_{l-1}{W}_{E\to I}^l+b_{E\to I}^l,$$

(18)

with $W_{E\to I}^l\in {\mathbb{R}}^{d_l\times d_l}$ and $b_{E\to I}^l\in {\mathbb{R}}^{d_l}$. The $\tanh (·)$ function constrains the gate to $[-1,1]$ so that the event cue can either suppress or enhance the current RGB sparse update. Since the gate operates only along the latent dimension $d_l$ and does not involve spatial convolution or self-attention, it introduces only $d_l^2+d_l$ parameters and approximately $B{N}_l{d}_l^2$ multiply-add operations for one directional gate. In our implementation, the latent dimension is set to $d_l=16$, so each directional gate contains only 272 parameters.

The RGB sparse code is then refined through an event-guided residual correction:

$${\tilde{I}}_l=I_{l-1}+\left(1+{\Gamma }_{E\to I}^l\right)\odot P_l^I\left(F_R^l-D_l^I\left(I_{l-1}\right)\right),$$

(19)

where $D_l^I(·)$ maps the RGB sparse code back to the RGB feature space, $P_l^I(·)$ projects the reconstruction residual into the sparse latent space, and ⊙ denotes element-wise multiplication. The residual term $F_R^l-D_l^I\left(I_{l-1}\right)$ measures the mismatch between the current RGB feature and its latent reconstruction, while the event-guided gate adaptively modulates the correction direction and magnitude according to the propagated event response.

To suppress noisy or redundant activations, a soft-shrinkage operator is further applied:

$$I_l=S\left({\tilde{I}}_l,{\lambda }_I^l\right),$$

(20)

where $S(·)$ performs sparsity-inducing shrinkage on the updated RGB sparse code. The purpose of this operator is to remove weak latent responses whose magnitudes are smaller than the adaptive threshold, while preserving stronger responses that are more likely to correspond to reliable UAV-related cues.

The adaptive threshold is predicted from the current RGB feature:

$${\lambda }_I^l=\mathrm{Softplus}\left({MLP}_I^l\left(F_R^l\right)\right),{\lambda }_I^l\in {\mathbb{R}}^{B\times N_l\times d_l}.$$

(21)

Here, ${MLP}_I^l(·)$ is applied token-wise to the current RGB feature and maps the feature dimension from $C_l$ to the sparse latent dimension $d_l$. Therefore, ${\lambda }_I^l$ is an adaptive threshold predicted for each sample, each spatial token, and each latent channel, rather than a global scalar threshold. This token-channel-wise threshold allows the sparse updating process to adapt to local image content and modality degradation.

The soft-shrinkage operator is defined as

$$S(x,\lambda )=sign\left(x\right)\odot max\left(\right|x|-\lambda ,0),$$

(22)

where ⊙ denotes element-wise multiplication. If the magnitude of a latent response is smaller than the corresponding threshold, it is suppressed to zero; otherwise, its magnitude is reduced by the threshold. In this way, soft shrinkage encourages sparse latent representations and suppresses weak, noisy, or redundant activations introduced during cross-modal residual updating. $\mathrm{Softplus}(·)$ is used to ensure that the predicted threshold is non-negative, which is required for valid shrinkage-based sparse regularization. Compared with a hard clipping operation, Softplus is smooth and differentiable, making the adaptive threshold prediction stable during end-to-end training.

After sparse updating, the enhanced RGB feature is reconstructed in a residual form:

$$F_R^{l^{\prime }}=F_R^l+D_l^{I^{\prime }}\left(I_l\right),$$

(23)

where $D_l^{I^{\prime }}(·)$ projects the refined sparse code back to the RGB feature space. This reconstruction preserves reliable RGB appearance structures while selectively emphasizing UAV-related cues recovered under event guidance.

3.3.2. RGB-Guided Event Sparse Updating

Symmetrically, the propagated RGB sparse code $I_{l-1}$ is used to guide event sparse updating.

Since the event branch is driven by a voxelized event representation, the intermediate event response retain a temporal-step layout. To make the operation in Figure 3b explicit, we use $M_T(·)$ to denote temporal aggregation and $B_T(·)$ to denote temporal broadcast. The temporal aggregation operator $M_T(·)$ maps the event response to the stage-level feature used for sparse updating:

$${\overline{F}}_E^l=M_T\left(F_E^l\right),{\overline{F}}_E^l\in {\mathbb{R}}^{B\times N_l\times C_l},$$

(24)

where ${\overline{F}}_E^l$ denotes the temporally aggregated event feature. If the event feature has already been aggregated before entering the bridge, $M_T(·)$ reduces to an identity operation.

The RGB-guided latent gate is defined as

$${\Gamma }_{I\to E}^l=tanh\left({Gate}_{I\to E}^l\left(I_{l-1}\right)\right),{\Gamma }_{I\to E}^l\in {\mathbb{R}}^{B\times N_l\times d_l},$$

(25)

where ${Gate}_{I\to E}^l(·)$ is implemented in the same way as ${Gate}_{E\to I}^l(·)$, namely a token-wise single linear layer followed by $\tanh (·)$. Therefore, the two directional gates in each bridge introduce only $2(d_l^2+d_l)$ parameters. With $d_l=16$, the bidirectional gates contain only 544 parameters in total for each bridge.

The event sparse code is updated as

$${\tilde{E}}_l=E_{l-1}+\left(1+{\Gamma }_{I\to E}^l\right)\odot P_l^E\left(F_E^l-D_l^E\left(E_{l-1}\right)\right),$$

(26)

where $D_l^E(·)$ and $P_l^E(·)$ are the reconstruction and projection operators for the event branch, respectively. Here, the residual term ${\overline{F}}_E^l-D_l^E\left(E_{l-1}\right)$ measures the mismatch between the current temporally aggregated event feature and the feature reconstructed from the propagated event sparse code. The RGB-guided gate modulates this residual correction in the sparse latent space, so that RGB-derived semantic cues can suppress background-triggered event responses while retaining motion-sensitive UAV responses.

The refined event sparse code is then regularized by

$$E_l=S\left({\tilde{E}}_l,{\lambda }_E^l\right),$$

(27)

where the adaptive threshold is predicted as

$${\lambda }_E^l=\mathrm{Softplus}\left({MLP}_E^l\left(F_E^l\right)\right),{\lambda }_E^l\in {\mathbb{R}}^{B\times N_l\times d_l}.$$

(28)

The event-side threshold ${\lambda }_E^l$ is predicted in a token-channel-wise manner from the temporally aggregated event feature ${\overline{F}}_E^l$. It is used to suppress weak or noisy event responses in the sparse latent space.

After sparse refinement, the enhanced event feature is reconstructed as

$$F_E^{l^{\prime }}=F_E^l+D_l^{E^{\prime }}\left(E_l\right),$$

(29)

where $D_l^{E^{\prime }}(·)$ maps the refined sparse code back to the event feature space. The temporal broadcast operator $B_T(·)$ then restores this correction to the temporal layout of the event branch:

$$F_E^{l^{\prime }}=F_E^l+B_T\left(\Delta {\overline{F}}_E^l\right),$$

(30)

where $B_T(·)$ broadcasts the reconstructed correction to match the temporal-bin or temporal-step structure of $F_E^l$. If the event feature has no explicit temporal dimension at this stage, $B_T(·)$ also reduces to an identity operation. In this way, RGB semantics provide stable appearance priors to filter unreliable event responses, while the event branch still preserves its motion-sensitive temporal characteristics.

3.3.3. Fusion of Enhanced Features

After bidirectional sparse mutual updating at level l, the bridge obtains the enhanced RGB feature $F_R^{l^{\prime }}$ and the enhanced event feature $F_E^{l^{\prime }}$. Instead of directly concatenating the two features, we use a lightweight dynamic fusion gate to predict modality-aware fusion weights:

$$[{\gamma }_R^l,{\gamma }_E^l]={Softmax}_m\left({MLP}_{\gamma }^l\left(\left[F_R^{l^{\prime }},F_E^{l^{\prime }}\right]\right)\right),$$

(31)

where $[·,·]$ denotes channel-wise concatenation, ${MLP}_{\gamma }^l(·)$ is a lightweight token-wise MLP, and ${Softmax}_m(·)$ is applied along the modality dimension. The predicted coefficients satisfy

$${\gamma }_R^l,{\gamma }_E^l\in {\mathbb{R}}^{B\times N_l\times C_l},{\gamma }_R^l+{\gamma }_E^l=\mathbf{1}.$$

(32)

Therefore, ${\gamma }_R^l$ and ${\gamma }_E^l$ are dynamically predicted token-channel-wise fusion weights. They are not global scalar weights, static channel-wise parameters, or standalone spatial attention maps. Instead, they adaptively modulate the RGB and event features for each spatial token and channel according to the local cross-modal feature responses.

The two enhanced features are then aggregated as

$$F_{RE}^l={\gamma }_R^l\odot F_R^{l^{\prime }}+{\gamma }_E^l\odot F_E^{l^{\prime }},$$

(33)

where ⊙ denotes element-wise multiplication. This dynamic reweighting allows the bridge to emphasize the more reliable modality at each spatial-token and channel position, while suppressing less reliable responses caused by RGB degradation or event noise.

The aggregated feature is further refined by a lightweight convolutional block:

$$F_f^l=SiLU\left(BN\left({Conv}_{3\times 3}\left(F_{RE}^l\right)\right)\right).$$

(34)

The resulting fused features $\{F_f^3,F_f^4,F_f^5\}$ are then fed into SGP-Neck for subsequent multiscale small-UAV enhancement.

3.4. Selective Gated Pyramid Neck

Although SMG-Bridge provides fused RGB–event features at multiple scales, reliable small-UAV detection still requires effective cross-scale aggregation. Low-level features retain fine localization cues but are sensitive to background clutter, whereas high-level features provide stronger semantics but may lose tiny-target details. To address this issue, we introduce the Selective Gated Pyramid Neck, which performs local response enhancement, top-down semantic injection, and bottom-up detail feedback in a gated manner, as shown in Figure 4.

Given the fused features $\{F_f^3,F_f^4,F_f^5\}$ from SMG-Bridge, the features from different stages are first projected to a unified pyramid dimension:

$$X_l={\varphi }_l\left(F_f^l\right),X_l\in {\mathbb{R}}^{B\times C_p\times H_l\times W_l},l\in \{3,4,5\},$$

(35)

where ${\varphi }_l(·)$ denotes a stage-specific $1\times 1$ convolution followed by batch normalization and SiLU activation. This operation aligns the channel dimension of the multiscale features to the unified pyramid channel number $C_p$, ensuring dimensional consistency in the subsequent addition and concatenation operations.

Each channel-aligned feature is then enhanced by the Local Response Perception Module (LRPM):

$$R_l=\sigma \left({Conv}_{1\times 1}\left({DWConv}_{3\times 3}\left(X_l\right)\right)\right),$$

(36)

$${\tilde{X}}_l=X_l+R_l\odot X_l,$$

(37)

where ${DWConv}_{3\times 3}(·)$ captures local spatial context, $\sigma (·)$ denotes the sigmoid function, and ${\tilde{X}}_l$ denotes the locally enhanced feature used in the subsequent pyramid aggregation.

Next, top-down semantic gating injects high-level context into finer-resolution features. We first define the top-down upsampling operation as

$${Up}_l\left(T_{l+1}\right)={\psi }_l^u\left(Interp\left(T_{l+1};H_l,W_l\right)\right),$$

(38)

where $Interp(·;H_l,W_l)$ denotes bilinear interpolation to the spatial resolution $(H_l,W_l)$, and ${\psi }_l^u(·)$ is a $1\times 1$ convolution used for channel alignment. Thus, ${Up}_l\left(T_{l+1}\right)\in {\mathbb{R}}^{B\times C_p\times H_l\times W_l}$.

The top-down pathway is then formulated as

$$T_5={\tilde{X}}_5,$$

(39)

$$G_l^s=\sigma \left({Conv}_{1\times 1}^{s,l}\left(\left[{\tilde{X}}_l,{Up}_l\left(T_{l+1}\right)\right]\right)\right),l\in \{4,3\},$$

(40)

$$T_l={\tilde{X}}_l+G_l^s\odot {Up}_l\left(T_{l+1}\right),l\in \{4,3\}.$$

(41)

Here, $[·,·]$ denotes channel-wise concatenation. Since both ${\tilde{X}}_l$ and ${Up}_l\left(T_{l+1}\right)$ have the same spatial resolution and channel dimension, their concatenation has the shape ${\mathbb{R}}^{B\times 2C_p\times H_l\times W_l}$. The $1\times 1$ convolution in Equation (40) maps the concatenated feature back to $C_p$ channels, and the sigmoid function produces $G_l^s\in {\mathbb{R}}^{B\times C_p\times H_l\times W_l}$. Therefore, $G_l^s$ is a spatial-channel-wise gate that adaptively controls the contribution of high-level semantic information at each spatial location and channel.

To further preserve localization-sensitive details, a bottom-up detail-gating path is adopted. The downsampling operation is defined as

$${Down}_l\left(F_P^{l-1}\right)={\psi }_l^d\left(F_P^{l-1}\right),$$

(42)

where ${\psi }_l^d(·)$ is implemented as a $3\times 3$ convolution with stride 2 and padding 1, followed by batch normalization and SiLU activation. It reduces the spatial resolution from $(H_{l-1},W_{l-1})$ to $(H_l,W_l)$ and outputs $C_p$ channels, such that ${Down}_l\left(F_P^{l-1}\right)\in {\mathbb{R}}^{B\times C_p\times H_l\times W_l}$.

The bottom-up pathway is formulated as

$$F_P^3=T_3,$$

(43)

$$G_l^d=\sigma \left({Conv}_{1\times 1}^{d,l}\left(\left[T_l,{Down}_l\left(F_P^{l-1}\right)\right]\right)\right),l\in \{4,5\},$$

(44)

$$F_P^l=T_l+G_l^d\odot {Down}_l\left(F_P^{l-1}\right),l\in \{4,5\}.$$

(45)

Similarly, $G_l^d\in {\mathbb{R}}^{B\times C_p\times H_l\times W_l}$ is a spatial-channel-wise gate predicted from the concatenation of $T_l$ and the downsampled lower-level pyramid feature. It adaptively controls how much fine-grained, localization-sensitive information is propagated from the lower-level, higher-resolution feature path to the current pyramid level. In this way, SGP-Neck performs dimensionally aligned top-down semantic enhancement and bottom-up detail refinement through explicit upsampling, downsampling, and spatial-channel-wise gating operations.

Finally, the enhanced pyramid features $\{F_P^3,F_P^4,F_P^5\}$ are fed into the YOLO-style detection head for multiscale UAV prediction.

4. Experiments and Results

4.1. Datasets and Implementation Details

We evaluate the proposed SMG-UAV on two RGB–event drone detection datasets, namely FRED and NeRDD. Both datasets provide synchronized RGB frames and event streams, making them suitable for evaluating the effectiveness of RGB–event fusion in UAV detection.

FRED. The Florence RGB–event Drone dataset (FRED) is a multimodal drone perception dataset designed for drone detection, tracking, and trajectory forecasting [17]. It provides spatio-temporally synchronized RGB video and event streams with dense UAV trajectory annotations. The dataset contains more than 7 h of annotated drone recordings, covers five different drone models, and includes challenging conditions such as rain, adverse illumination, distractors, and diverse motion patterns. In our experiments, FRED is used as the primary benchmark to evaluate the detection performance and robustness of the proposed method in realistic RGB–event anti-UAV scenarios.

NeRDD. NeRDD is a Neuromorphic-RGB Drone Detection dataset specifically collected for Event-RGB drone detection [18]. It contains more than 3.5 h of spatio-temporally synchronized RGB–event drone recordings, corresponding to approximately 7 h of multimodal footage. The dataset is divided into 115 videos, and both modalities are provided at HD resolution of $1280\times 720$ with 30 FPS. Since NeRDD contains synchronized RGB and event data with drone annotations, it is used as an additional benchmark to evaluate the performance consistency of SMG-UAV across different UAV RGB–event benchmarks.

Evaluation metrics. Following common object detection protocols, we report ${\mathrm{AP}}_{50}$, ${\mathrm{AP}}_{75}$, and ${\mathrm{AP}}_{50:95}$. ${\mathrm{AP}}_{50}$ and ${\mathrm{AP}}_{75}$ denote the average precision at IoU thresholds of 0.50 and 0.75, respectively. ${\mathrm{AP}}_{50:95}$ denotes the mean average precision averaged over IoU thresholds from 0.50 to 0.95 with a step size of 0.05. These metrics jointly evaluate coarse localization accuracy, strict localization quality, and overall detection performance.

Implementation details. All experiments are conducted on a high-performance computational server equipped with an Xeon(R) Platinum 8470Q CPU and an NVIDIA RTX PRO 6000 Blackwell GPU. The software environment is built on Ubuntu 22.04, Python 3.12, PyTorch 2.8.0, and CUDA 12.8. The spiking components in the proposed Spiking CSPDarknet are implemented using SpikingJelly 0.14 [51].

All models are trained from scratch for up to 200 epochs. To preserve the fine-grained appearance and weak structural cues of UAV targets, the input resolution is fixed at $1280\times 720$ during both training and evaluation. For a fair and controlled comparison, all methods use the same sequence-level dataset split, input resolution, training budget, spatial preprocessing, optimization protocol, and evaluation metrics.

The compared methods are reproduced using their official implementations and released model configurations whenever available. The official network architecture and method-specific components are retained, while only the adaptations required for FRED and NeRDD, including the dataset path, annotation format, number of target classes, input resolution, and input channel configuration, are introduced. No additional method-specific hyperparameter search or preferential tuning is performed for any baseline.

Because different event-based methods are originally designed for different event representations, their event encodings are not forcibly unified. For all event-only and RGB–event methods, the raw event stream is first temporally aligned with the corresponding RGB frame interval and is then converted into the event representation required by the respective method. Specifically, SMG-UAV converts the asynchronous event stream into an event voxel grid with $T=3$ temporal bins and two polarity channels, resulting in a six-channel event representation. For the compared event-only and RGB–event methods, we retain the native event encoding adopted by their official implementations, such as accumulated event frames or voxel grids, together with the corresponding temporal-bin and polarity settings. This protocol preserves the original design of each method while ensuring that all methods use the same synchronized RGB–event samples and evaluation protocol.

For the common optimization protocol, stochastic gradient descent is used with a momentum of 0.937 and a weight decay of 0.0005. The learning-rate schedule consists of linear warm-up during the first three epochs, followed by cosine annealing. The initial learning rate is set to 0.01 and decays to 0.0001. An early-stopping strategy with a patience of 30 epochs is applied, and the best-performing model weights on the validation set are used for final evaluation. Therefore, the compared methods share the same optimization settings and training budget, while their official architectures and native eventbrepresentation designs are retained.

4.2. Comparison with State-of-the-Art Methods

We compare SMG-UAV with state-of-the-art methods on FRED and NeRDD. The compared methods include representative RGB-only detectors, event-only detectors, and RGB–event fusion detectors. Specifically, the RGB-only detectors include YOLOv12 [52], MambaYOLO [53], and RT-DETR [54]; the event-only detectors include RVT [55], SAST [56], and SMamba [57]; and the RGB–event fusion detectors include FPN-Fusion [12], RENet [13], SODFormer [14], and EOLO [15].

For a fair comparison, all methods are trained and evaluated under the same dataset split, input resolution, and evaluation protocol whenever applicable, while retaining the original event encoding form of each compared method. To reduce the influence of random initialization and training stochasticity, each method is trained three times with different random seeds. The quantitative results are reported in

Table 1. Comparison of different methods on FRED and NeRDD over three independent training runs. Results are reported as mean ± standard deviation. The best results are highlighted in bold.

Input Modality	Method	FRED			NeRDD
		${\mathbf{AP}}_{\mathbf{50}}$	${\mathbf{AP}}_{\mathbf{75}}$	${\mathbf{AP}}_{\mathbf{50}:\mathbf{95}}$	${\mathbf{AP}}_{\mathbf{50}}$	${\mathbf{AP}}_{\mathbf{75}}$	${\mathbf{AP}}_{\mathbf{50}:\mathbf{95}}$
RGB	YOLOv12	$35.2\pm 0.7$	$11.4\pm 0.5$	$13.5\pm 0.6$	$35.8\pm 0.6$	$13.5\pm 0.4$	$16.4\pm 0.5$
	MambaYOLO	$36.6\pm 0.5$	$12.2\pm 0.4$	$14.3\pm 0.5$	$39.5\pm 0.6$	$14.0\pm 0.4$	$17.7\pm 0.5$
	RT-DETR	$34.0\pm 0.6$	$10.7\pm 0.5$	$11.9\pm 0.4$	$32.8\pm 0.7$	$11.2\pm 0.4$	$15.6\pm 0.5$
Event	RVT	$79.3\pm 0.3$	$33.2\pm 0.5$	$46.7\pm 0.4$	$81.5\pm 0.4$	$24.8\pm 0.6$	$33.5\pm 0.4$
	SAST	$77.9\pm 0.5$	$32.2\pm 0.4$	$45.0\pm 0.6$	$80.2\pm 0.5$	$23.8\pm 0.5$	$32.2\pm 0.3$
	SMamba	$81.7\pm 0.4$	$35.8\pm 0.3$	$47.7\pm 0.6$	$82.8\pm 0.3$	$25.1\pm 0.3$	$33.9\pm 0.5$
RGB + Event	FPN-Fusion	$80.4\pm 0.5$	$34.3\pm 0.3$	$43.1\pm 0.4$	$82.5\pm 0.6$	$26.4\pm 0.2$	$33.6\pm 0.4$
	EOLO	$78.7\pm 0.5$	$31.7\pm 0.3$	$39.3\pm 0.4$	$85.1\pm 0.4$	$27.3\pm 0.3$	$41.2\pm 0.2$
	RENet	$82.0\pm 0.5$	$35.6\pm 0.5$	$47.0\pm 0.4$	$82.8\pm 0.4$	$26.6\pm 0.6$	$39.6\pm 0.5$
	SODFormer	$82.4\pm 0.1$	$35.9\pm 0.4$	$48.1\pm 0.3$	$83.9\pm 0.2$	$26.8\pm 0.3$	$38.7\pm 0.2$
	SMG-UAV	$\mathbf{89}.\mathbf{3}\pm \mathbf{0}.\mathbf{2}$	$\mathbf{37}.\mathbf{2}\pm \mathbf{0}.\mathbf{4}$	$\mathbf{51}.\mathbf{6}\pm \mathbf{0}.\mathbf{3}$	$\mathbf{88}.\mathbf{7}\pm \mathbf{0}.\mathbf{2}$	$\mathbf{30}.\mathbf{1}\pm \mathbf{0}.\mathbf{3}$	$\mathbf{49}.\mathbf{5}\pm \mathbf{0}.\mathbf{4}$

as mean ± standard deviation.

As shown in Table 1, RGB-only detectors show limited performance on both FRED and NeRDD. Although RGB frames provide rich texture, color, and appearance information, these cues become unreliable when UAV targets are small, distant, blurred, weakly contrasted, or affected by illumination degradation. For example, the best RGB-only ${\mathrm{AP}}_{50:95}$ reaches only $14.3\pm 0.5$ on FRED and $17.7\pm 0.5$ on NeRDD, indicating that appearance-based detection alone is insufficient for robust anti-UAV perception in challenging dynamic scenes.

Event-only detectors achieve substantially better results than RGB-only detectors on both datasets. This demonstrates the importance of high-temporal-resolution motion cues for UAV detection. Event streams can provide more discriminative motion-sensitive responses, especially under fast motion, motion blur, and illumination variation. Among the event-only methods, SMamba obtains the best ${\mathrm{AP}}_{50:95}$ of $47.7\pm 0.6$ on FRED and $33.9\pm 0.5$ on NeRDD. However, event-only detection still has limitations. Event responses may become sparse when the UAV moves slowly or appears at a long distance, and irrelevant background motion may introduce noisy activations.

RGB–event fusion methods generally improve over RGB-only methods, confirming the benefit of multimodal sensing for drone detection. However, the results also show that not all fusion strategies consistently outperform the strongest event-only baseline. For instance, some fusion methods achieve lower mean ${\mathrm{AP}}_{50:95}$ than SMamba on FRED or only marginal gains on NeRDD. This suggests that directly combining RGB and event features is not sufficient. When one modality is degraded or when the two modalities contain inconsistent responses, conventional fusion strategies may introduce unreliable information rather than suppress it.

In contrast, SMG-UAV achieves the best mean performance across all metrics on both datasets. On FRED, SMG-UAV reaches $89.3\pm 0.2$ ${\mathrm{AP}}_{50}$, $37.2\pm 0.4$ ${\mathrm{AP}}_{75}$, and $51.6\pm 0.3$ ${\mathrm{AP}}_{50:95}$, outperforming the strongest competing method by 6.8, 1.3, and 3.4 points in terms of mean performance, respectively. On NeRDD, SMG-UAV obtains $88.7\pm 0.2$ ${\mathrm{AP}}_{50}$, $30.1\pm 0.3$ ${\mathrm{AP}}_{75}$, and $49.5\pm 0.4$ ${\mathrm{AP}}_{50:95}$, exceeding the best competing method by 3.6, 2.8, and 8.3 points in terms of mean performance, respectively. Although the ${\mathrm{AP}}_{75}$ improvement on FRED is smaller than the improvements in ${\mathrm{AP}}_{50}$ and ${\mathrm{AP}}_{50:95}$, the standard deviation of SMG-UAV remains low, indicating that the gain is stable across different random seeds. These results suggest that the proposed method exhibits both strong detection performance and stable training behavior across two UAV RGB–event benchmarks.

Although AP-based metrics provide a standard and comprehensive evaluation of detection accuracy, they do not fully reflect the operational reliability required by practical anti-UAV surveillance. In such scenarios, missed targets may lead to delayed warning, while frequent false alarms may increase the burden of downstream tracking, verification, and response modules. Therefore, in addition to ${\mathrm{AP}}_{50}$, ${\mathrm{AP}}_{75}$, and ${\mathrm{AP}}_{50:95}$, we further report precision, recall, F1-score, false positives per frame (FP/frame), and miss rate on the FRED dataset in

Table 2. Additional anti-UAV-oriented evaluation metrics on the FRED dataset. Precision, recall, F1-score, and miss rate are reported in %. FP/frame denotes the average number of false positives per frame. All metrics are computed under the same confidence threshold and IoU matching criterion. The best results are highlighted in bold.

Input	Method	Precision	Recall	F1	FP/Frame	Miss Rate
RGB	YOLOv12	43.8	34.9	38.9	0.224	65.1
	MambaYOLO	45.1	36.8	40.5	0.224	63.2
	RT-DETR	42.7	32.4	36.9	0.217	67.6
Event	RVT	83.6	78.7	81.1	0.077	21.3
	SAST	82.1	76.9	79.4	0.084	23.1
	SMamba	84.7	80.9	82.8	0.073	19.1
RGB + Event	FPN-Fusion	82.8	79.4	81.1	0.082	20.6
	EOLO	80.9	76.5	78.6	0.090	23.5
	RENet	83.9	80.1	82.0	0.077	19.9
	SODFormer	84.5	81.7	83.1	0.075	18.3
	SMG-UAV	91.2	88.6	89.9	0.043	11.4

. We select FRED for this additional reliability-oriented evaluation because it provides a more comprehensive RGB–event anti-UAV benchmark with diverse UAV motion patterns, target scales, illumination conditions, background clutter, and challenging surveillance scenarios.

For a fair comparison, these additional metrics are computed from the post-NMS detection results under the same confidence threshold and IoU matching criterion for all compared methods. A predicted bounding box is counted as a true positive if its confidence score is higher than the predefined confidence threshold and its IoU with an unmatched ground-truth box is larger than 0.5. Predictions that do not match any ground-truth box are counted as false positives. Ground-truth boxes that are not matched by any valid prediction are treated as missed targets. In our evaluation, the confidence threshold is set to 0.3 for all methods, and the IoU threshold for matching is set to 0.5.

The additional metrics are computed as follows:

$$\mathrm{Precision}={\displaystyle \frac{TP}{TP+FP}},\mathrm{Recall}={\displaystyle \frac{TP}{N_{\mathrm{gt}}}},$$

(46)

$$\mathrm{F}1={\displaystyle \frac{2·\mathrm{Precision}·\mathrm{Recall}}{\mathrm{Precision}+\mathrm{Recall}}},\mathrm{Miss}\mathrm{Rate}=1-\mathrm{Recall},$$

(47)

$$\mathrm{FP}/\mathrm{frame}={\displaystyle \frac{FP}{N_{\mathrm{frames}}}},$$

(48)

where $TP$ and $FP$ denote true positives and false positives, respectively, $N_{\mathrm{gt}}$ denotes the number of ground-truth UAV instances, and $N_{\mathrm{frames}}$ denotes the number of evaluated frames. For anti-UAV surveillance, recall and FP/frame are particularly important because they directly reflect missed-warning risk and false-alarm burden.

As shown in Table 2, the proposed SMG-UAV not only achieves the highest AP-based accuracy, but also provides a better balance between recall and false alarms. Compared with RGB-only and event-only detectors, SMG-UAV achieves higher recall, lower FP/frame, and a lower miss rate. This is important for practical low-altitude surveillance, where a detector is often used as the front-end of subsequent tracking, verification, and warning modules.

Although the overall comparison provides a general evaluation of detection performance, it cannot fully reveal the reliability of anti-UAV detectors under specific adverse conditions. In practical low-altitude surveillance scenarios, UAV targets may be extremely small, blurred by fast motion, degraded by abnormal illumination, submerged in complex backgrounds, or confused with bird-like moving distractors. Therefore, we further conduct a challenge-oriented robustness evaluation on the FRED dataset.

Specifically, we manually curate five UAV-specific challenging subsets from the FRED test set. The original bounding-box annotations are kept unchanged, and only frame-level difficulty attributes are additionally assigned for evaluation. Each selected RGB frame is paired with the event stream accumulated within the corresponding RGB frame interval. The five subsets include small target, motion blur, extreme illumination, background-embedded target, and bird-like distractor. The small-target subset contains UAV instances whose bounding-box size is smaller than $16\times 16$ pixels. The extreme-illumination subset includes both overexposed and underexposed scenes. The background-embedded subset refers to cases where the UAV is visually similar to the surrounding background or partially obscured by cluttered structures. The bird distractor subset contains scenes with target-like moving objects that may cause false alarms in anti-UAV detection. The statistics of these subsets are summarized in

Table 3. Statistics and qualification criteria of the manually curated challenging subsets from the FRED test set. Each RGB frame is paired with the event stream accumulated within the corresponding RGB frame interval. Since the five subsets are not mutually exclusive, the same frame or UAV instance may appear in more than one subset.

Subset	Qualification Criterion	Number of Frames	Number of UAV Instances
Small Target	At least one UAV has both an annotated bounding-box width and height smaller than 16 pixels. Candidate frames are manually reviewed to remove inaccurate annotations.	7598	8944
Motion Blur	The UAV exhibits evident directional smearing, elongation, boundary diffusion, or contour degradation caused by relative motion or exposure.	6392	7210
Extreme Illumination	Severe underexposure, overexposure, glare, or illumination variation causes substantial loss of UAV appearance details or local contrast.	7145	7867
Background-Embedded	The UAV is visually similar to the surrounding background or partially obscured by cluttered structures, making foreground–background separation difficult.	6724	7238
Bird Distractor	At least one annotated UAV and one or more non-UAV bird-like moving objects appear in the same frame and may cause confusion or false alarms.	4783	5941

, and representative examples are shown in Figure 5. These subsets are used only for evaluation and are not involved in the training process. The five subsets are not mutually exclusive, and a frame may be assigned to multiple difficulty attributes if multiple challenges coexist.

For the small-target subset, candidate samples are first selected from the original annotations by identifying frames that contain at least one UAV bounding box with both width and height smaller than 16 pixels. The candidate samples are then manually re-examined to exclude cases with inaccurate, misaligned, or otherwise unreliable original annotations. For the other four difficulty attributes, namely motion blur, extreme illumination, background-embedded, and bird distractor, frame-level labels are manually assigned according to the predefined visual qualification criteria described in Table 3.

To reduce subjectivity during subset construction, two annotators independently assign the five frame-level difficulty attributes. The annotators examine the RGB frames and refer to the original UAV bounding-box annotations. The corresponding event representations and temporally adjacent frames are additionally inspected when necessary, particularly when determining motion blur, background interference, or bird-like distractors. Cases in which the two annotators produce inconsistent assignments are independently reviewed and adjudicated by a third experienced annotator.

We evaluate representative methods from different input modalities on these five challenging subsets and report ${\mathrm{AP}}_{50}$ as the robustness metric. ${\mathrm{AP}}_{50}$ is adopted because this analysis focuses on whether UAV targets can be reliably detected under severe degradation, especially when the targets are small, weak, or visually ambiguous. The results are shown in

Table 4. Robustness comparison on the manually curated challenging subsets from FRED. ${\mathrm{AP}}_{50}$ is reported for each subset, and the best results are highlighted in bold.

Method	Small Target	Motion Blur	Extreme Illumination	Background- Embedded	Bird Distractor
YOLOv12	11.4	10.6	5.7	4.2	35.3
MambaYOLO	12.8	10.1	4.9	3.9	36.9
SMamba	26.9	32.7	36.7	39.2	33.8
RENet	24.6	29.1	38.9	33.6	34.1
SODFormer	26.3	31.5	41.2	38.1	35.7
SMG-UAV	31.7	36.9	47.6	45.6	46.2

.

As shown in Table 4, SMG-UAV achieves the best ${\mathrm{AP}}_{50}$ on all five challenging subsets, demonstrating its robustness under diverse anti-UAV failure factors. On the small-target subset, SMG-UAV obtains 31.7 ${\mathrm{AP}}_{50}$, outperforming the strongest baseline SMamba by 4.8 points. In contrast, RGB-only detectors only achieve 11.4 and 12.8 ${\mathrm{AP}}_{50}$, showing that appearance information alone is insufficient when UAVs occupy only a few pixels.

For motion blur, SMG-UAV reaches 36.9 ${\mathrm{AP}}_{50}$, exceeding SMamba by 4.2 points and SODFormer by 5.4 points. Event-only detection performs clearly better than RGB-only detection in this subset because event streams preserve motion-sensitive brightness changes. However, the further gain of SMG-UAV shows that event cues are more effective when they are used to guide RGB feature reconstruction rather than being used independently.

Under extreme illumination, the advantage of SMG-UAV becomes more evident. RGB-only methods drop to 5.7 and 4.9 ${\mathrm{AP}}_{50}$ because UAV appearance cues are severely degraded by overexposure or underexposure. Event-only and fusion-based methods are more robust, but SMG-UAV still improves the best competing result from 41.2 to 47.6 ${\mathrm{AP}}_{50}$. This suggests that the proposed sparse mutual guidance can better exploit illumination-insensitive event responses while suppressing unreliable RGB features.

For the background-embedded subset, SMG-UAV achieves 45.6 ${\mathrm{AP}}_{50}$, surpassing the strongest baseline by 6.4 points. This subset is particularly challenging because the UAV is visually similar to the surrounding structures or partially submerged by cluttered backgrounds. The result indicates that SMG-UAV can recover more discriminative target representations by jointly using motion-sensitive event cues and RGB semantic constraints.

The bird distractor subset further evaluates the false-alarm resistance of different methods. Although RGB-only MambaYOLO obtains a relatively high ${\mathrm{AP}}_{50}$ of 36.9, conventional event-only and fusion-based methods remain vulnerable to target-like distractors and background motion. SMG-UAV achieves 46.2 ${\mathrm{AP}}_{50}$, improving the best competing result by 9.3 points. This result suggests that the bidirectional guidance in SMG-Bridge helps suppress irrelevant event responses and improves discrimination between real UAV targets and target-like distractors.

Overall, the challenge-oriented evaluation demonstrates that the proposed method is not only superior in overall benchmark performance, but also more reliable under key anti-UAV degradation factors. The consistent gains across small target, motion blur, extreme illumination, background embedding, and distractor interference provide stronger evidence for the effectiveness of sparse mutual guidance in practical low-altitude UAV detection.

4.3. Computational Complexity and Inference Efficiency

Since practical anti-UAV systems require both high detection accuracy and real-time response, we further evaluate the computational complexity and inference efficiency of different methods. The evaluated metrics include the number of parameters, GFLOPs, FPS, and inference latency. All methods are evaluated under the same input resolution and batch size of 1. The server-side FPS is measured on the same hardware platform used for training and evaluation, so that the reported speed is consistent with the experimental environment used for the accuracy comparison. The reported latency denotes the average network forward inference time per sample, excluding disk I/O, data loading and event voxel preprocessing. For RGB–event methods, both RGB and event inputs are included in the network inference pipeline. The latency is derived from FPS $T_{\mathrm{latency}}=1000/\mathrm{FPS}$ ms.

As shown in

Table 5. Computational complexity and server-side inference efficiency comparison. Params and GFLOPs denote the model size and theoretical computational cost, respectively. FPS is evaluated under the same input resolution, batch size of 1, and server hardware platform used for training and evaluation.

Input	Method	Params (M)	GFLOPs	FPS	Latency (ms)
RGB	YOLOv12	19.6	123.6	113	8.85
	MambaYOLO	19.1	116.5	119	8.40
	RT-DETR	20.1	144.3	107	9.35
Event	RVT	18.5	31.2	167	5.99
	SAST	19.1	37.1	146	6.84
	SMamba	23.7	72.8	98	10.20
RGB + Event	FPN-Fusion	65.6	283.7	65	15.38
	EOLO	46.2	100.9	92	10.87
	RENet	37.7	102.7	93	10.75
	SODFormer	86.5	279.7	68	14.71
	SMG-UAV	18.7	66.2	132	7.58

, some event-only models, such as RVT and SAST, achieve faster inference and lower parameter counts compared with SMG-UAV, due to their single-modality design. In contrast, SMG-UAV introduces a dual-branch RGB–event architecture with spiking event processing, sparse mutual guidance, and pyramid feature enhancement. Although this adds some computational overhead compared with the fastest event-only models, SMG-UAV maintains a moderate parameter size of 18.7 M, 66.2 GFLOPs, and 132 FPS with 7.58 ms average network latency. More importantly, it consistently achieves the highest detection accuracy across ${\mathrm{AP}}_{50}$, ${\mathrm{AP}}_{75}$, and ${\mathrm{AP}}_{50:95}$ metrics. Therefore, SMG-UAV provides a favorable balance between computational efficiency and detection reliability, making it more suitable for practical low-altitude anti-UAV surveillance scenarios where both accuracy and real-time response are critical.

To further evaluate embedded deployment potential, we also deploy the compared models on an NVIDIA Jetson Orin Nano development board (NVIDIA, Santa Clara, CA, USA). The Jetson Orin Nano is a widely used edge-AI development platform for embedded vision, robotics, autonomous systems, intelligent surveillance, and industrial inspection. Its compact form factor and limited computational resources make it suitable for evaluating the efficiency and practical deployment potential of the proposed method on resource-constrained edge-computing platforms. The embedded-platform FPS is measured with batch size 1 after model warm-up, excluding disk I/O, data loading and event voxel preprocessing. The results are reported in

Table 6. Embedded-platform inference efficiency on the NVIDIA Jetson Orin Nano development board (NVIDIA, Santa Clara, CA, USA). FPS is measured with batch size 1 after model warm-up.

Input	Method	Params (M)	GFLOPs	FPS	Latency (ms)
RGB	YOLOv12	19.6	123.6	36	27.78
	MambaYOLO	19.1	116.5	38	26.32
	RT-DETR	20.1	144.3	31	32.26
Event	RVT	18.5	31.2	47	21.28
	SAST	19.1	37.1	42	23.81
	SMamba	23.7	72.8	29	34.48
RGB + Event	FPN-Fusion	65.6	283.7	20	50.00
	EOLO	46.2	198.4	28	35.71
	RENet	37.7	102.7	30	33.33
	SODFormer	86.5	279.7	22	45.45
	SMG-UAV	18.7	66.2	40	25.00

.

It should be noted that the reported latency measures only network forward inference. The complete end-to-end latency of a deployed RGB–event anti-UAV system may additionally include event stream buffering, event voxel construction, RGB–event synchronization, image resizing, and communication overhead. These factors are implementation- and hardware-dependent.

Despite these additional factors, SMG-UAV achieves a forward inference speed of 40 FPS on the NVIDIA Jetson Orin Nano development board, demonstrating that the proposed method can provide a favorable balance between detection accuracy and real-time performance on edge-computing platforms. This indicates its practical potential for low-altitude anti-UAV surveillance in resource-constrained embedded scenarios.

4.4. Qualitative Comparison and Heatmap Analysis

The quantitative results in Table 1 demonstrate the overall accuracy and challenge-specific robustness of SMG-UAV. However, numerical metrics alone cannot fully reveal how different detectors behave in practical anti-UAV scenarios. Therefore, we further provide qualitative detection comparisons and response heatmap visualizations to analyze the localization behavior and feature focus of different methods.

Figure 6 shows representative detection results under challenging scenes, including extreme illumination, background clutter, weak small targets, and low-contrast environments. For each scene, we compare representative RGB-only, event-only, RGB–event fusion, and proposed SMG-UAV detectors. The confidence value displayed beside each bounding box in Figure 6 denotes the final detection confidence of the prediction retained after non-maximum suppression (NMS). For a fair comparison, all compared methods use the same confidence threshold of $0.30$ and the same NMS IoU threshold of $0.50$.

The visual results indicate that RGB-only methods are sensitive to severe illumination degradation and weak target appearance. When the UAV is overexposed, underexposed, or visually similar to the background, RGB-only detectors may miss the target or produce unstable confidence scores. Event-only methods can capture motion-sensitive responses and are less affected by static appearance degradation, but their predictions may become fragmented when event responses are sparse or when background motion introduces noise. Existing RGB–event fusion methods improve detection results by combining appearance and motion cues, but they may still suffer from localization drift or false responses when one modality is unreliable.

In contrast, SMG-UAV provides more stable detection results across different challenging cases. It produces tighter bounding boxes and more reliable confidence scores for distant or weak UAV targets. This advantage is especially clear in extreme-illumination and background-embedded scenes, where UAV appearance is severely degraded and the target region is difficult to distinguish from the surrounding background. These qualitative observations are consistent with the robustness analysis in Table 4.

To further explain the behavior of different detectors, Figure 7 presents Grad-CAM visualizations generated using a standard Grad-CAM implementation. For each model, the UAV detection score is used as the target output, and the feature layer immediately before the detection head is selected as the target layer. The generated heatmaps are resized to the input image resolution and independently normalized to the range $[0,1]$ using min–max normalization. The same color map is applied to all compared methods, where warmer colors indicate regions with greater relative contribution to the corresponding UAV prediction and cooler colors indicate lower relative contribution. Since each heatmap is independently normalized, the visualization is used to compare the spatial localization and concentration of model attention rather than the absolute response magnitude across different models.

As shown in Figure 7, several existing RGB–event fusion methods produce diffuse or spatially shifted attention regions, with activations extending to irrelevant background structures. In contrast, SMG-UAV produces more compact and accurately localized attention around the true UAV regions while suppressing spurious background responses. This suggests that the proposed method learns more discriminative and target-aware feature representations under challenging anti-UAV conditions.

The qualitative detection results and heatmap visualizations provide intuitive evidence for the effectiveness of SMG-UAV. The proposed method not only improves quantitative detection performance, but also exhibits more reliable localization behavior and more discriminative internal responses in challenging anti-UAV environments.

4.5. Ablation Studies

To verify the effectiveness of the proposed components, we conduct a series of ablation studies on the FRED dataset. All variants are trained and evaluated under the same settings as the full model. Unless otherwise specified, only the analyzed component is changed, while the remaining architecture and training protocol are kept unchanged. ${\mathrm{AP}}_{50}$, ${\mathrm{AP}}_{75}$, and ${\mathrm{AP}}_{50:95}$ are reported to evaluate detection accuracy at different localization thresholds.

4.5.1. Effectiveness of Main Components

We first evaluate the contribution of the main components in SMG-UAV through a progressive ablation study on the FRED dataset. The baseline is a basic dual-stream RGB–event detector, in which both branches use conventional CSPDarknet backbones, the event input is represented as a three-channel accumulated event frame, and cross-modal fusion is implemented by direct concatenation. Based on this baseline, we progressively introduce the event voxel representation, the Spiking CSPDarknet event encoder, SMG-Bridge, and the SGP-Neck. In addition to ${\mathrm{AP}}_{50}$, ${\mathrm{AP}}_{75}$, and ${\mathrm{AP}}_{50:95}$,

Table 7. Ablation study of the main components on FRED.

Configuration	${\mathrm{AP}}_{50}$	${\mathrm{AP}}_{75}$	${\mathrm{AP}}_{50:95}$	Params (M)	GFLOPs
Baseline	73.4	30.2	38.7	16.0	54.1
+Event voxel representation	77.9	32.5	44.1	16.2	56.1
+Spiking CSPDarknet encoder	80.2	35.3	44.5	16.8	58.9
+SMG-Bridge	87.6	36.7	48.9	17.8	63.4
+SGP-Neck	89.3	37.2	51.6	18.7	66.2

reports the cumulative parameter count and GFLOPs of each configuration to quantify the computational overhead introduced by the corresponding components.

As shown in Table 7, the baseline achieves 73.4 ${\mathrm{AP}}_{50}$, 30.2 ${\mathrm{AP}}_{75}$, and 38.7 ${\mathrm{AP}}_{50:95}$, with 16.0 M parameters and 54.1 GFLOPs. Replacing the accumulated event frame with the event voxel representation improves the performance to 77.9 ${\mathrm{AP}}_{50}$, 32.5 ${\mathrm{AP}}_{75}$, and 44.1 ${\mathrm{AP}}_{50:95}$, corresponding to improvements of 4.5, 2.3, and 5.4 points, respectively. This demonstrates that preserving the temporal distribution and polarity information of events within the RGB frame interval provides more informative motion cues than a temporally collapsed event frame.

The event voxel representation changes the event input from the three-channel accumulated event frame used in the baseline to a voxel tensor. The increased input channel dimension slightly enlarges the input layer of the event branch and introduces additional network-forward computation. Consequently, the parameter count increases from 16.0 M to 16.2 M, while the computational cost increases from 54.1 to 56.1 GFLOPs, corresponding to additional costs of 0.2 M parameters and 2.0 GFLOPs.

Further introducing the Spiking CSPDarknet event encoder raises the performance to 80.2 ${\mathrm{AP}}_{50}$, 35.3 ${\mathrm{AP}}_{75}$, and 44.5 ${\mathrm{AP}}_{50:95}$. This corresponds to improvements of 2.3, 2.8, and 0.4 points, respectively. The Spiking CSPDarknet encoder increases the cumulative model size from 16.2 M to 16.8 M parameters and the computational cost from 56.1 to 58.9 GFLOPs, introducing 0.6 M additional parameters and 2.8 GFLOPs. These results suggest that the spiking event branch better matches the sparse and motion-triggered characteristics of event data and improves hierarchical event feature extraction with a relatively limited computational overhead.

The largest accuracy gain is obtained by replacing direct concatenation with SMG-Bridge. This modification increases the performance to 87.6 ${\mathrm{AP}}_{50}$, 36.7 ${\mathrm{AP}}_{75}$, and 48.9 ${\mathrm{AP}}_{50:95}$, bringing gains of 7.4, 1.4, and 4.4 points over the preceding configuration, respectively. Meanwhile, SMG-Bridge introduces 1.0 M additional parameters and 4.5 GFLOPs, increasing the cumulative complexity from 16.8 M parameters and 58.9 GFLOPs to 17.8 M parameters and 63.4 GFLOPs. The substantial accuracy improvement relative to this moderate computational increase demonstrates that reliability-aware sparse mutual guidance is more effective than direct feature aggregation for exploiting complementary RGB–event information.

Finally, adding SGP-Neck further improves the results to 89.3 ${\mathrm{AP}}_{50}$, 37.2 ${\mathrm{AP}}_{75}$, and 51.6 ${\mathrm{AP}}_{50:95}$. Compared with the SMG-Bridge configuration, SGP-Neck provides additional gains of 1.7, 0.5, and 2.7 points, respectively. It introduces 0.9 M additional parameters and 2.8 GFLOPs, resulting in a full-model complexity of 18.7 M parameters and 66.2 GFLOPs. This result shows that lightweight gated multiscale enhancement remains beneficial after cross-modal fusion, particularly for small and weak UAV targets whose responses may be attenuated during hierarchical feature propagation.

Overall, the complete SMG-UAV improves the baseline by 15.9 ${\mathrm{AP}}_{50}$, 7.0 ${\mathrm{AP}}_{75}$, and 12.9 ${\mathrm{AP}}_{50:95}$, while introducing 2.7 M additional parameters and 12.1 GFLOPs. Among the proposed components, SMG-Bridge provides the largest accuracy improvement, whereas the event voxel representation, Spiking CSPDarknet encoder, and SGP-Neck introduce relatively limited additional complexity. These results demonstrate that the proposed components provide substantial detection gains with controlled computational overhead, resulting in a favorable accuracy–complexity trade-off.

4.5.2. Effect of Bidirectional Mutual Guidance

To further analyze the cross-modal interaction mechanism in SMG-Bridge, we compare different guidance directions. The direct fusion variant removes mutual guidance and aggregates RGB and event features directly. The event-to-image and image-to-event variants retain only one guidance direction, while the bidirectional variant corresponds to the full SMG-Bridge.

As shown in

Table 8. Ablation study of bidirectional mutual guidance in SMG-Bridge. The best results are highlighted in bold.

Configuration	${\mathrm{AP}}_{50}$	${\mathrm{AP}}_{75}$	${\mathrm{AP}}_{50:95}$
Direct fusion	82.2	35.7	45.1
Event-to-image only	86.9	36.7	49.8
Image-to-event only	85.1	36.1	48.4
Bidirectional guidance	89.3	37.2	51.6

, direct fusion achieves 82.2 ${\mathrm{AP}}_{50}$, 35.7 ${\mathrm{AP}}_{75}$, and 45.1 ${\mathrm{AP}}_{50:95}$. Both one-way guidance variants improve over this baseline. Event-to-image guidance increases the performance to 86.9 ${\mathrm{AP}}_{50}$, 36.7 ${\mathrm{AP}}_{75}$, and 49.8 ${\mathrm{AP}}_{50:95}$, indicating that event cues provide effective motion-sensitive structure for enhancing degraded RGB representations. Image-to-event guidance also improves the results to 85.1 ${\mathrm{AP}}_{50}$, 36.1 ${\mathrm{AP}}_{75}$, and 48.4 ${\mathrm{AP}}_{50:95}$, showing that RGB appearance semantics help suppress noisy or irrelevant event responses.

The complete bidirectional guidance achieves the best performance, reaching 89.3 ${\mathrm{AP}}_{50}$, 37.2 ${\mathrm{AP}}_{75}$, and 51.6 ${\mathrm{AP}}_{50:95}$. Compared with event-to-image only, it further improves ${\mathrm{AP}}_{50}$ and ${\mathrm{AP}}_{50:95}$ by 2.4 and 1.8 points, respectively. These results show that the two guidance directions are complementary rather than redundant. By jointly exploiting event-guided RGB recovery and RGB-guided event refinement, SMG-Bridge produces more reliable cross-modal representations for robust UAV detection.

4.5.3. Effect of Sparse Thresholding and Guidance Gate

We further analyze two internal designs of SMG-Bridge: the adaptive sparse threshold and the dynamic guidance gate. As shown in

Table 9. Ablation study of sparse thresholding and guidance gate in SMG-Bridge. The best results are highlighted in bold.

Variant	${\mathrm{AP}}_{50}$	${\mathrm{AP}}_{75}$	${\mathrm{AP}}_{50:95}$
Without guidance gate	84.3	36.2	45.8
Static scalar gate	86.1	36.7	47.9
Without adaptive threshold	88.0	36.9	49.4
Full SMG-Bridge	89.3	37.2	51.6

, removing the guidance gate reduces ${\mathrm{AP}}_{50:95}$ from 51.6 to 45.8, indicating that ungated cross-modal propagation introduces more unreliable responses. Replacing the dynamic gate with a static scalar also degrades the performance to 47.9 ${\mathrm{AP}}_{50:95}$, showing that spatially adaptive guidance is more effective than global weighting. Removing the adaptive sparse threshold lowers ${\mathrm{AP}}_{50:95}$ to 49.4, suggesting that sparse thresholding contributes to suppressing noisy or unreliable responses during fusion. The full SMG-Bridge achieves the best results, demonstrating that both adaptive thresholding and dynamic guidance are important for reliable RGB–event fusion.

4.5.4. Effect of Event Voxel Configuration

We further investigate the influence of two key parameters in the event voxel representation: the number of temporal bins T and the event accumulation window $\Delta t$. To isolate the effect of each factor, only one parameter is varied at a time, while the remaining network architecture, training settings, input resolution, dataset split, and evaluation protocol are kept unchanged. When evaluating the number of temporal bins, the event accumulation window is fixed at $33.3$ ms, corresponding to one RGB frame interval on FRED. When evaluating the accumulation window, the number of temporal bins is fixed at the default value of $T=3$.

The positive and negative event polarities are accumulated separately in each temporal bin. Therefore, an event voxel with T temporal bins is represented as $X_E\in {\mathbb{R}}^{2T\times H\times W}$, where the factor of two corresponds to the two event polarities. The default configuration uses $T=3$, resulting in a six-channel event representation. Changing T modifies the input channel dimension of the event branch and therefore slightly affects the parameter count and network-forward GFLOPs.

As shown in

Table 10. Effect of the number of temporal bins T in the event voxel representation on FRED. The event accumulation window is fixed at $33.3$ ms. The input channel number is $2T$, corresponding to T temporal bins and two event polarities. The selected default configuration is highlighted in bold.

Temporal Bins T	Input Channels	Params (M)	GFLOPs	${\mathrm{AP}}_{50}$	${\mathrm{AP}}_{75}$	${\mathrm{AP}}_{50:95}$
1	2	18.1	64.3	84.6	32.5	48.1
2	4	18.4	65.1	86.1	36.7	47.9
3	6	18.7	66.2	89.3	37.2	51.6
4	8	19.1	67.2	88.9	37.1	50.9
5	10	19.3	68.6	88.8	36.9	50.7

, using too few temporal bins excessively compresses the temporal distribution of the event stream and limits the representation of short-term UAV motion. Increasing T preserves finer temporal information and initially improves detection performance. However, an excessively large T distributes the available events over more temporal intervals, making the response within each bin increasingly sparse. It also increases the number of input channels and slightly raises the parameter count and network-forward computation. The configuration with $T=3$ provides the best overall balance among temporal resolution, event density, detection accuracy, and computational complexity. Therefore, $T=3$ is adopted as the default setting in SMG-UAV.

Table 11. Effect of different event accumulation windows on FRED. Since the input channel dimension remains fixed, the parameter count and network-forward GFLOPs are identical for all configurations. The selected window is highlighted in bold.

Window $\mathbf{\Delta }\mathit{t}$	Approx. RGB Interval	${\mathrm{AP}}_{50}$	${\mathrm{AP}}_{75}$	${\mathrm{AP}}_{50:95}$
$16.7$ ms	$0.5\times$	84.6	32.5	48.1
$33.3$ ms	$1.0\times$	89.3	37.2	51.6
$50.0$ ms	$1.5\times$	89.2	36.8	50.9
$66.7$ ms	$2.0\times$	88.7	36.5	50.2

analyzes the influence of the event accumulation duration. A short accumulation window contains relatively few events and may provide insufficient motion evidence for distant, slowly moving, or weak UAV targets. Increasing the window produces denser event observations and can improve the stability of event feature extraction. Nevertheless, an excessively long window may accumulate irrelevant background events, generate longer motion trails, and weaken the temporal alignment between the event representation and the current RGB frame. The accumulation window of $33.3$ ms achieves the best overall performance and is used in the final model.

4.5.5. Contribution of SMG-Bridge at Different Feature Levels

We further investigate the contribution of SMG-Bridge at different feature levels of the dual-branch backbone. SMG-Bridge can be applied to the L3, L4, and L5 stages, which correspond to high-, medium-, and low-resolution feature representations, respectively. To isolate the contribution of bridge placement, all remaining components, including the event voxel representation, Spiking CSPDarknet encoder, SGP-Neck, detection head, and training protocol, are kept unchanged. When SMG-Bridge is disabled at a feature level, the RGB and event features at that level are directly concatenated along the channel dimension.

As shown in

Table 12. Ablation study of SMG-Bridge placement at different feature levels on FRED. L3, L4, and L5 denote the high-, medium-, and low-resolution feature stages, respectively. The best results are highlighted in bold.

SMG-Bridge Placement	${\mathrm{AP}}_{50}$	${\mathrm{AP}}_{75}$	${\mathrm{AP}}_{50:95}$
L3 only	76.1	30.2	40.1
L4 only	74.8	29.8	39.6
L5 only	72.3	28.6	38.2
L3 + L4	82.1	33.6	45.4
L4 + L5	81.9	32.2	44.8
L3 + L4 + L5	89.3	37.2	51.6

, the L3 bridge operates on higher-resolution features and primarily improves the preservation and cross-modal enhancement of fine spatial details, which are particularly important for small and distant UAV targets. The L4 and L5 bridges operate on progressively deeper features and contribute stronger semantic and contextual interaction between the RGB and event modalities.

Combining SMG-Bridge at multiple levels produces further improvements over using any individual level. In particular, the complete L3 + L4 + L5 configuration achieves the best performance, reaching 89.3 ${\mathrm{AP}}_{50}$, 37.2 ${\mathrm{AP}}_{75}$, and 51.6 ${\mathrm{AP}}_{50:95}$. These results indicate that high-resolution spatial guidance and deeper semantic guidance are complementary rather than redundant, supporting the multilevel deployment of SMG-Bridge in the final architecture.

4.6. Cross-Dataset Transfer Evaluation

To further examine the transferability of SMG-UAV across different anti-UAV data distributions, we conduct bidirectional cross-dataset experiments between FRED and NeRDD. Two transfer settings are considered: training on FRED and directly testing on NeRDD, denoted as FRED → NeRDD, and training on NeRDD and directly testing on FRED, denoted as NeRDD → FRED. The corresponding FRED → FRED and NeRDD → NeRDD results are also reported as in-domain references.

It should be noted that FRED was developed by extending NeRDD with additional sequences and more diverse target scales, backgrounds, illumination conditions, and motion patterns. Therefore, the two datasets are related rather than completely independent, and the two transfer directions have different levels of difficulty. FRED → NeRDD represents transfer from a broader data distribution to a related and relatively narrower distribution, whereas NeRDD → FRED requires the model to generalize from the more limited NeRDD distribution to the more diverse scenarios contained in FRED. Accordingly, the NeRDD → FRED direction provides a more challenging assessment of cross-dataset transferability.

For each transfer direction, SMG-UAV is trained from scratch using only the training split of the source dataset. The best-performing checkpoint is selected exclusively according to the validation split of the same source dataset and is then directly evaluated on the test split of the target dataset. No target-domain fine-tuning, parameter adaptation, additional training, hyperparameter search, or confidence-threshold adjustment is performed. Target-domain annotations are used only for the final calculation of the evaluation metrics. The confidence threshold, non-maximum suppression settings, and evaluation implementation remain unchanged across the in-domain and cross-dataset experiments.

As shown in

Table 13. Cross-dataset transfer performance of SMG-UAV between FRED and NeRDD. The original dataset splits are retained, and no target-domain fine-tuning, parameter adaptation, hyperparameter search, or threshold adjustment is performed.

Training Dataset	Testing Dataset	${\mathrm{AP}}_{50}$	${\mathrm{AP}}_{75}$	${\mathrm{AP}}_{50:95}$
FRED	FRED	89.3	37.2	51.6
FRED	NeRDD	87.5	29.8	48.7
NeRDD	NeRDD	88.7	30.1	49.5
NeRDD	FRED	66.2	25.4	33.9

, the model trained on FRED and directly evaluated on NeRDD achieves 87.5 ${\mathrm{AP}}_{50}$, 29.8 ${\mathrm{AP}}_{75}$, and 48.7 ${\mathrm{AP}}_{50:95}$. Compared with the model trained and evaluated on NeRDD, the transferred model shows only limited reductions of 1.2, 0.3, and 0.8 points in ${\mathrm{AP}}_{50}$, ${\mathrm{AP}}_{75}$, and ${\mathrm{AP}}_{50:95}$, respectively. This relatively small performance gap is consistent with the relationship between the two datasets. FRED extends the data distribution represented by NeRDD with additional sequences and more diverse target scales, backgrounds, illumination conditions, and motion patterns. Training on FRED therefore enables the model to learn from a broader but related distribution, and the resulting representations remain effective when transferred to NeRDD.

In the reverse direction, the model trained on NeRDD and directly evaluated on FRED obtains 66.2 ${\mathrm{AP}}_{50}$, 25.4 ${\mathrm{AP}}_{75}$, and 33.9 ${\mathrm{AP}}_{50:95}$. Compared with the FRED in-domain results, this corresponds to reductions of 23.1, 11.8, and 17.7 points, respectively. The substantially larger degradation indicates that the comparatively narrower NeRDD training distribution does not sufficiently cover the additional target appearances, scales, scene structures, illumination variations, and motion conditions contained in FRED. Consequently, NeRDD → FRED represents the more challenging transfer direction and provides a stricter assessment of the ability of SMG-UAV to generalize from a limited source distribution to broader anti-UAV scenarios.

Overall, the bidirectional experiments reveal a clear asymmetric transfer pattern. The FRED → NeRDD setting retains performance close to the NeRDD in-domain reference, whereas the NeRDD → FRED setting exhibits a considerable decrease under the broader target distribution. Because FRED was developed by extending NeRDD, the favorable FRED → NeRDD result should be interpreted as transfer between closely related datasets rather than generalization to a completely independent domain. Nevertheless, the results demonstrate that the complementary RGB appearance cues and event-based motion representations learned by SMG-UAV exhibit meaningful transferability across related anti-UAV data distributions. The degradation in the more difficult NeRDD → FRED direction also indicates that robust generalization from a restricted training distribution to more diverse real-world environments remains an important challenge.

5. Discussions

5.1. Real-Time Deployment and Sensing Limitations

In practical anti-UAV surveillance, the required processing speed is jointly affected by UAV velocity, target distance, camera field of view, and imaging frame rate. Faster or closer UAVs produce larger image-plane displacements within the same time interval and therefore require lower detection latency. In the current setup, RGB frames are acquired at approximately 30 FPS, corresponding to an interval of about 33.3 ms, and the events accumulated within each RGB interval are converted into a synchronized voxel representation. Although the event camera records asynchronous brightness changes at a much finer temporal resolution, the current detector produces one synchronized representation and detection result for each RGB frame interval. SMG-UAV achieves 132 FPS with a network-forward latency of 7.58 ms on the server GPU and 40 FPS with a latency of 25.00 ms on the Jetson Orin Nano. Both latency values are shorter than one RGB frame interval, indicating that the detector can support frame-rate-level real-time processing without introducing an inference backlog. However, one RGB frame interval is used only as a practical reference under the current setup, because the acceptable detection delay in an operational system also depends on UAV speed, observation distance, surveillance coverage, and the required response time.

Nevertheless, the reported latency covers network inference only. The complete alert delay also includes RGB acquisition, event accumulation, RGB–event synchronization, voxel construction, image preprocessing, non-maximum suppression, communication, and alert generation. Moreover, the sensing configuration imposes several practical limitations. A wide field of view increases surveillance coverage but reduces the number of pixels occupied by distant UAVs, whereas a narrow field of view improves target resolution but increases the risk of losing fast-moving targets. The effective detection range is also constrained by sensor resolution, lens focal length, target size, atmospheric visibility, and target–background contrast.

The current datasets do not provide complete calibrated target-to-camera distances or physical UAV dimensions for all sequences. Therefore, a fixed maximum detection distance cannot be reliably determined from the available data. Instead, practical detectability is evaluated in the image domain. In particular, the manually curated small-target subset contains UAV instances whose annotated bounding-box width and height are both smaller than 16 pixels, providing an image space assessment of the method under extremely small-target conditions and serving as a proxy for long-range detection difficulty. The physical distance corresponding to this image space size varies with the UAV dimensions, camera resolution, lens focal length, field of view, and atmospheric visibility.

Synchronization or geometric calibration errors may cause cross-modal feature misalignment, particularly for small and rapidly moving UAVs. In addition, hovering, slowly moving, or radially moving targets may produce weak event responses, while camera vibration, moving vegetation, clouds, and illumination changes may generate substantial background event activity.

Future work will focus on asynchronous or adaptive-window inference, lightweight end-to-end processing, improved RGB–event synchronization and calibration, and adaptive suppression of background events to reduce practical alert latency and improve robustness under weak-motion and long-range surveillance conditions.

5.2. Failure Case Analysis

To further analyze the limitations of the proposed method in safety-related anti-UAV scenarios, Figure 8 presents several representative failure cases of SMG-UAV, including both false negatives and false positives. In the first two examples, the detector fails to detect the UAV.

In Figure 8a, the UAV is extremely small and appears under weak relative motion, while the RGB image is blurred and the event stream contains only sparse responses. As a result, neither modality provides sufficiently reliable evidence for detection. In Figure 8b, the scene is captured under nighttime conditions, and the UAV is nearly invisible in the RGB image. Meanwhile, the UAV is hovering or moving only weakly, so the event modality also produces limited motion cues, which leads to a missed detection.

In the last two examples, the detector produces false alarms caused by bird distractors. As shown in Figure 8c,d, the bird targets are small and visually ambiguous in the RGB images, while the event modality mainly captures motion responses without explicit semantic discrimination. Therefore, bird motion patterns may generate event responses similar to those of UAVs, leading to incorrect detections. These cases indicate that although SMG-UAV improves robustness under challenging conditions, failure cases may still occur when both appearance cues and motion cues are weak, ambiguous, or inconsistent. Similar false alarms may also be caused by insects, distant aircraft, wires, cloud boundaries, and moving background structures, because their small-scale appearance or event responses may resemble those of UAVs under particular viewing conditions.

Overall, the failure cases suggest several directions for future improvement, including stronger modeling of weak-motion targets, better suppression of bird-like distractors, and tighter integration of temporal verification and semantic discrimination for safety-critical anti-UAV deployment.

6. Conclusions

This paper presented SMG-UAV, a sparse mutual guided RGB–event fusion network for robust UAV detection in challenging low-altitude anti-UAV surveillance scenarios. Different from conventional RGB–event detectors that mainly rely on direct feature aggregation, the proposed framework explicitly models complementary cross-modal recovery under asymmetric degradation. Specifically, an appearance-oriented RGB branch and a Spiking CSPDarknet event branch are used to encode dense appearance cues and sparse motion-sensitive responses, respectively. On top of this, SMG-Bridge performs bidirectional sparse mutual guidance to recover degraded target structures and suppress unreliable cross-modal interference, while SGP-Neck further enhances weak UAV responses through selective multiscale feature aggregation.

Extensive experiments on FRED and NeRDD demonstrated that SMG-UAV consistently outperforms representative RGB-only, event-only, and RGB–event fusion methods. In addition to the overall benchmark comparison, challenge-oriented robustness evaluation on manually curated FRED subsets further showed clear advantages under small-target, motion-blur, extreme-illumination, background-embedded, and bird distractor conditions. Ablation studies confirmed the effectiveness of the event voxel representation, Spiking CSPDarknet, bidirectional mutual guidance, adaptive sparse thresholding, dynamic reliability gating, and multiscale enhancement. Qualitative visualizations and failure-case analysis further demonstrated the advantages and remaining challenges of the proposed method in complex anti-UAV scenes.

Several limitations should nevertheless be acknowledged. First, SMG-UAV depends on spatially and temporally synchronized RGB–event sensing, and synchronization or calibration errors may reduce the reliability of cross-modal interaction, particularly for small and rapidly moving targets. Second, hovering, slowly moving, or radially moving UAVs may generate weak event responses, limiting the complementary motion information available to the detector. Third, although the method has been evaluated on FRED and NeRDD, its generalization to substantially different environments, sensor configurations, camera resolutions, fields of view, and acquisition systems remains to be further verified. Finally, the current embedded evaluation is limited to the Jetson Orin Nano and reports network-forward inference performance rather than complete end-to-end system latency, which additionally includes sensor acquisition, event accumulation, synchronization, voxel construction, preprocessing, post-processing, communication, and alert generation.

Future work will therefore focus on broader cross-environment and cross-sensor evaluation, improved synchronization and calibration robustness, adaptive modeling of weak-motion event responses, and end-to-end optimization on additional embedded platforms. We will also investigate asynchronous or adaptive-window inference and temporal distractor verification to further improve practical reliability and reduce alert latency in real anti-UAV deployment.