I propose a unified detection framework for UAV drone imagery that treats small-object detection not as an isolated head-level problem, but as a coupled problem of reliable shallow representation, cross-scale spatial alignment, high-order context aggregation, and controlled multi-scale feedback. The method, which I call LHM-DEIM, is built on a DEIM-DFINE baseline and introduces three tightly connected components: a Laplacian-of-Gaussian initial feature extraction module, a hypergraph hybrid encoding neck, and a mutual guided fusion module. My design is motivated by the observation that UAV drone images are not simply “images with smaller objects.” They are images in which object evidence, background texture, sensor noise, compression artifacts, and scale variation interact simultaneously. A detector that improves only one of these factors often shifts errors rather than removing them. Therefore, I focus on constructing reliable node representations, aligning those nodes in a common spatial support, aggregating group-wise context, and then feeding that context back to the detection scales in a bidirectional manner.
The UAV drone setting is particularly demanding. A single frame may contain hundreds of tiny vehicles or pedestrians, strong perspective distortion, motion blur, low contrast, and dense clutter. In such conditions, an object may occupy only a few pixels, while background regions such as roofs, roads, and vegetation may contain edge patterns that resemble weak object boundaries. Standard convolutional downsampling can suppress high-frequency evidence before the detector has a chance to use it. Standard feature pyramids can propagate semantic information across scales, but they do not explicitly enforce that features from different levels are compared at the same spatial location. Attention and transformer-based relation modules can model long-range dependencies, but when the input nodes are noisy or scale-inconsistent, relation propagation may amplify incorrect associations. I therefore treat the problem as one of constructing dependable multi-scale nodes and then aggregating them with high-order, locality-controlled relations.
In my formulation, a UAV drone image is processed by a backbone that produces multi-scale features, a hybrid encoder that aligns and aggregates those features, and a decoder that predicts objects. The LHM-DEIM pipeline is designed so that each component has a specific role. The Laplacian-of-Gaussian initial feature extraction module, denoted LoGStem, improves the identifiability of shallow nodes by enhancing high-frequency structure while suppressing isolated noise. The hypergraph hybrid encoding neck, denoted H-HEN, first aligns P2 through P5 features to a common P4 grid through spatial scale alignment, and then builds a hypergraph over the aligned nodes to capture group-wise context. The mutual guided fusion module, denoted MutualGuideFusion, returns the aggregated context to the detection scales and exchanges information between P4 and P5 features through channel recalibration and bidirectional guidance. The three modules form a closed information loop rather than a simple stack of independent improvements.
I evaluate LHM-DEIM on VisDrone2019 and UAVDT. On VisDrone2019, the baseline achieves 34.3% AP0.5, 19.3% AP, and 12.3% APs. With the complete LHM-DEIM design, the model reaches 38.2% AP0.5, 21.6% AP, and 14.8% APs, while the parameter count increases only from 3.73M to 3.89M. This corresponds to a 3.9 percentage point gain in AP0.5 and a 2.5 percentage point gain in APs. The gains are not obtained by a large increase in model size. On UAVDT, the model improves AP from 19.1% to 20.9%, AP0.5 from 32.1% to 34.9%, and APs from 14.8% to 15.3%, with a parameter increase of only 0.16M. These results support my central claim: for UAV drone detection, a carefully designed combination of edge-aware stem processing, scale alignment, hypergraph context, and mutual guidance can deliver a better accuracy-efficiency balance than simply enlarging the model or adding an independent detection head.
Problem Setting and Notation
I consider an input image $I \in \mathbb{R}^{H \times W \times 3}$ captured by a UAV drone. The backbone produces feature maps at four scales, denoted $P_2$, $P_3$, $P_4$, and $P_5$. Their spatial resolutions decrease progressively, while their semantic abstraction increases. The detection decoder operates on three scales in the baseline setting. My goal is to use the high-resolution P2 information without introducing a separate P2 prediction branch, because adding a P2 head increases computation and can also introduce unstable low-level predictions. Instead, I map P2, P3, P4, and P5 into a common P4 spatial support and let the hypergraph encoder aggregate context on that support. I then use MutualGuideFusion to feed the aggregated context back to the P4 and P5 detection scales.
Let $F_0$ denote the initial feature after the first convolutional mapping in the stem. Let $K_{\text{LoG}}$ be a two-dimensional Laplacian-of-Gaussian kernel. Let $K_G$ be a Gaussian kernel with channel-adaptive learning. Let $D_2(\cdot)$ and $D_1(\cdot)$ denote two-times and one-time downsampling, and let $U(\cdot)$ denote upsampling. Let $\mathrm{Trans}(\cdot)$ denote a transformer block used to enrich the highest-level feature with global dependencies. Let $H$ denote the hypergraph incidence matrix, and let $\epsilon$ denote the distance threshold for hyperedge construction. A summary of notation is given in Table 1.
| Symbol | Meaning |
|---|---|
| $I$ | Input UAV drone image |
| $P_2,P_3,P_4,P_5$ | Backbone feature maps at four scales |
| $F_0$ | Initial feature after first convolution in the stem |
| $K_{\text{LoG}}$ | Laplacian-of-Gaussian kernel |
| $K_G$ | Gaussian smoothing kernel |
| $F_{\text{stem}}$ | Output of LoGStem |
| $F_{\text{enc}}$ | Aligned and fused encoder feature |
| $D_{ij}$ | Euclidean distance between node features $x_i$ and $x_j$ |
| $H_{ij}$ | Binary hypergraph incidence value |
| $\epsilon$ | Distance threshold for hyperedge construction |
| $F_{\text{hyp}}$ | Hypergraph-enhanced feature |
| $F_{\text{out}}$ | Output of MutualGuideFusion |
| $\mathrm{AP}_{0.5}$ | Average precision at IoU threshold 0.5 |
| $\mathrm{AP}_s$ | Average precision for small objects |
Motivation from UAV Drone Challenges
The difficulty of UAV drone detection is often summarized as “small objects,” but I find that this description hides three distinct failure modes. The first is early texture loss. Vehicles, pedestrians, and cyclists may occupy only a few pixels. Their boundaries are weak, and the contrast between object and background is often low. When a backbone applies repeated strided convolution or pooling, high-frequency evidence can be attenuated before the deeper layers receive it. The second failure mode is cross-scale spatial inconsistency. Features from different levels have different receptive fields and different spatial resolutions. If they are fused without explicit alignment, the network may combine semantically useful context with spatially mismatched details. The third failure mode is unreliable relation propagation. Attention and graph-like modules assume that nodes are meaningful. If a node contains mostly background noise, or if its scale is inconsistent with that of its neighbors, then message passing can spread errors rather than correct them.
These failure modes suggest a different design principle. Instead of adding a module only at the detection head, I should improve the quality of the nodes that enter the relation module, align those nodes to a shared coordinate system, aggregate high-order context with a controlled locality radius, and then return the context to the detection scales. This principle leads directly to LoGStem, H-HEN, and MutualGuideFusion. LoGStem addresses early texture loss. H-HEN addresses cross-scale inconsistency and unreliable relation propagation. MutualGuideFusion addresses the gap between the encoded context and the detection scales.
| UAV drone challenge | Failure mode | Design response |
|---|---|---|
| Small object size | Weak boundaries and texture disappearance after downsampling | LoGStem with LoG edge prior and Gaussian residual |
| Large scale variation | Features from different levels are not directly comparable | SSA maps P2-P5 to a common P4 grid |
| Dense clutter and occlusion | Pairwise relations are insufficient for group context | HyperCompute builds hyperedges over similar nodes |
| Background confusion | Context propagation may amplify background associations | Distance threshold $\epsilon$ controls relation locality |
| Deep feature attenuation | Shallow details are overwhelmed by high-level semantics | MutualGuideFusion performs bidirectional exchange |
Overall Architecture of LHM-DEIM
The LHM-DEIM architecture consists of a backbone, a hybrid encoder neck, and a decoder. The backbone extracts multi-scale features from the input UAV drone image. The hybrid encoder neck contains spatial scale alignment, hypergraph construction, and hypergraph convolution. The decoder produces classification and regression outputs. The three proposed modules are inserted as follows. LoGStem replaces the original stem and produces an improved initial representation. H-HEN replaces the conventional neck and produces context-enhanced features at the P4 support. MutualGuideFusion connects the context-enhanced features to the P4 and P5 detection scales. The decoder then uses the refined features for final prediction.
The design is intentionally asymmetric. I do not add a new detection head at P2. Instead, I use P2 as an enhancement source for the P4 representation. This choice is important for UAV drone applications because P2 contains useful high-resolution detail but also contains the most background clutter and the least semantic abstraction. If P2 were given its own detection head, the model would need to suppress many false positives at high resolution. By aligning P2 to the P4 grid and using it as an enhancement, I retain high-resolution cues without making the decoder responsible for an additional unstable scale. Similarly, P5 is not discarded. It provides the strongest semantic context, which is especially useful for distinguishing small objects from similar background patterns.
| Stage | Operation | Output |
|---|---|---|
| Input | UAV drone image | $I$ |
| Stem | LoGStem | $F_{\text{stem}}$ |
| Backbone | Multi-scale extraction | $P_2,P_3,P_4,P_5$ |
| Neck alignment | Spatial scale alignment | Aligned features on P4 grid |
| Neck fusion | Channel concatenation and compression | $F_{\text{enc}}$ |
| Context | Hypergraph construction and HyperCompute | $F_{\text{hyp}}$ |
| Feedback | MutualGuideFusion | $F_{\text{out}}$ for P4/P5 |
| Decoder | Detection head | Class and box predictions |
LoGStem: Laplacian-of-Gaussian Initial Feature Extraction
I introduce LoGStem as the front-end feature extraction module. The motivation is that a UAV drone image often contains weak object boundaries, low contrast, and compression noise. A conventional stem may downsample too aggressively and lose the very evidence that distinguishes a small object from background texture. LoGStem combines a learnable Laplacian-of-Gaussian edge prior, a Gaussian residual smoothing branch, and a multi-scale structural fusion branch. The module is differentiable and can be trained end-to-end.
The first part of LoGStem applies a $7\times7$ convolution to the input to obtain $F_0$. A two-dimensional LoG kernel $K_{\text{LoG}}$ is then applied as a depthwise convolution. Batch normalization and a SiLU activation are used to form a residual enhancement:
$$ F_{\text{LoG}} = \phi\left( \mathrm{BN}\left( F_0 * K_{\text{LoG}} \right) \right) + \mathrm{BN}(F_0) $$
Here, $*$ denotes channel-wise convolution, $\phi$ is the SiLU activation, and $\mathrm{BN}$ is batch normalization. The LoG response strengthens edges and fine structures while suppressing flat regions. For a UAV drone image, this is valuable because object boundaries are often the most stable cue when color and texture are degraded.
The second part is a Gaussian residual branch. After a lightweight downsampling operation produces an intermediate feature $F_D$, a channel-adaptive Gaussian kernel $K_G$ is applied. A pure Gaussian smoothing operation would reduce noise but could also erase tiny objects. Therefore, I use a residual form:
$$ F_G = \phi\left( \mathrm{BN}\left( F_D * K_G \right) \right) + \mathrm{BN}(F_D) $$
This branch suppresses random noise while preserving high-frequency details through the identity path. In my experiments, the residual form is important because UAV drone images frequently contain isolated high-frequency noise from sensor and compression artifacts. If the stem simply enhanced all high frequencies, it would also enhance noise. The Gaussian residual separates stable structure from random noise.
The third part is the deep robust feature downsampling block, which I abbreviate as DRFD. It splits the feature into two parallel paths. One path uses a $3\times3$ convolution with stride 2 to emphasize texture and edge information. The other path uses a $3\times3$ max-pooling operation with stride 2 to aggregate stable low-frequency context. The two outputs are concatenated and compressed by a $1\times1$ convolution:
$$ F_c = \mathrm{BN}\left( \mathrm{Conv}_{3\times3}(F_G) \right), \quad s=2 $$
$$ F_m = \mathrm{BN}\left( \mathrm{MaxPool}_{3\times3}(F_G) \right), \quad s=2 $$
$$ F_{\text{stem}} = \mathrm{Conv}_{1\times1}\left( [F_c, F_m] \right) $$
The final output $F_{\text{stem}}$ has resolution $H/4 \times W/4$ and serves as the input to the subsequent backbone stages. The design provides both fine geometric description and macro semantic consistency. In the context of the full LHM-DEIM model, LoGStem improves the reliability of the nodes that later enter the hypergraph. If shallow textures are already corrupted by background noise, the distance threshold in the hypergraph may connect object nodes to background nodes. By enhancing edges and suppressing isolated noise, LoGStem makes node similarity more meaningful.
| Component | Operation | Purpose in UAV drone detection |
|---|---|---|
| LoG filter | $7\times7$ convolution followed by LoG depthwise convolution and residual | Enhance weak object boundaries and fine structures |
| Gaussian residual | Gaussian smoothing with identity path | Suppress noise without erasing small-object details |
| DRFD convolution path | $3\times3$ convolution with stride 2 | Preserve texture and edge cues |
| DRFD pooling path | $3\times3$ max pooling with stride 2 | Aggregate stable low-frequency context |
| Fusion | $1\times1$ convolution over concatenated paths | Balance fine detail and semantic consistency |
Hypergraph Hybrid Encoding Neck
The second major component is the hypergraph hybrid encoding neck, H-HEN. It replaces the conventional feature pyramid neck and consists of two coupled mechanisms: spatial scale alignment and hypergraph-based context computation. The rationale is straightforward. Before the network can compute high-order relations among UAV drone objects, it must ensure that the features being compared are spatially aligned and semantically compatible. SSA provides the common spatial support. HyperCompute then builds a hypergraph on that support and performs message passing.
Spatial Scale Alignment
Conventional feature pyramid networks use P3, P4, and P5 for top-down and bottom-up fusion. High-resolution P2 features are often underused. In UAV drone imagery, however, P2 contains critical information about tiny objects. I therefore explicitly include P2 in the neck. To avoid adding a P2 detection head, I align P2, P3, P4, and P5 to the P4 spatial grid. The P4 scale is a compromise: it is not as noisy as P2 and not as coarse as P5. It provides a reasonable balance between spatial detail and semantic stability. Let $D_2(\cdot)$ and $D_1(\cdot)$ denote two-times and one-time downsampling, and let $U(\cdot)$ denote upsampling. The four aligned branches are:
$$ P_2′ = D_2(P_2) $$
$$ P_3′ = D_1\left( \mathrm{Conv}_{1\times1}(P_3) \right) $$
$$ P_4′ = \mathrm{Conv}_{1\times1}(P_4) $$
$$ P_5′ = U\left( \mathrm{Trans}\left( \mathrm{Conv}_{1\times1}(P_5) \right) \right) $$
After alignment, the four branches are concatenated along the channel dimension and compressed by a $1\times1$ convolution:
$$ F_{\text{enc}} = \mathrm{Conv}_{1\times1}\left( [P_2′, P_3′, P_4′, P_5′] \right) $$
The transformer block on P5 is used to inject global dependencies before upsampling. This is useful for UAV drone scenes because the highest-level feature has the largest receptive field and can provide scene-level context, such as road direction or building layout. The aligned features $P_2’$, $P_3’$, $P_4’$, and $P_5’$ all share the same spatial resolution. Therefore, each spatial position in $F_{\text{enc}}$ corresponds to the same coordinate in all four original scales. This property is essential for the next step, because the hypergraph compares node features by distance. If the nodes came from different spatial grids, the distance would mix scale mismatch with semantic difference.
I note that aligning P2 to P4 is not lossless. Two-times downsampling and channel projection inevitably compress some high-frequency detail. However, the goal is not to preserve all P2 pixels. The goal is to transfer the P2 cues that are useful for small-object edges, texture, and localization into the P4 representation. The ablation results show that this transfer is beneficial. Without SSA, the hypergraph operates on less consistent nodes, and the gain is smaller.
| Feature | Original role | Alignment operation | Contribution to P4 support |
|---|---|---|---|
| $P_2$ | Highest resolution, rich detail | Two-times downsampling | Small-object edges and fine texture |
| $P_3$ | High resolution with moderate semantics | One-time downsampling and convolution | Local structure and object parts |
| $P_4$ | Middle scale, balanced semantics | Channel projection | Base spatial support |
| $P_5$ | Lowest resolution, strongest semantics | Transformer, convolution, upsampling | Global scene context |
Hypergraph Construction
After alignment, I flatten the spatial dimensions of $F_{\text{enc}}$ and treat each position as a node. Let $x_i$ and $x_j$ be the feature vectors of two nodes. I compute the Euclidean distance:
$$ D_{ij} = \| x_i – x_j \|_2^2, \quad i,j = 1,2,\dots,N $$
The binary hypergraph incidence matrix is then defined by thresholding:
$$ H_{ij} = \begin{cases} 1, & D_{ij} < \epsilon \\ 0, & D_{ij} \ge \epsilon \end{cases} $$
Here, $H \in \mathbb{R}^{B \times N \times N}$, $B$ is the batch size, and $N$ is the number of nodes per sample. Each vertex $V_i$ corresponds to an $\epsilon$-ball hyperedge that contains all vertices whose distance from $V_i$ is less than $\epsilon$. This definition preserves the symmetry that every node can act as a context center. It also allows one hyperedge to cover multiple related nodes, which is a natural way to represent group relationships. In a UAV drone image, a small vehicle may be partially occluded, or a group of pedestrians may be densely packed. Pairwise edges may be insufficient to capture the shared context of such groups. Hyperedge construction can aggregate evidence from several mutually supporting nodes.
The threshold $\epsilon$ controls the locality of information propagation. If $\epsilon$ is too small, a hyperedge contains very few nodes. Context from different visible parts of the same object or from adjacent complementary regions may be disconnected. If $\epsilon$ is too large, background nodes such as road, roof, and vegetation may be included in the same hyperedge as the object. The group representation is then diluted by background responses. In my experiments, $\epsilon=128$ provides the best balance on VisDrone2019. This value should not be interpreted as universally optimal. It reflects the feature scale and dataset characteristics of my training setup. The theoretical role of $\epsilon$ is to balance context completeness and relation noise.
HyperCompute and Message Passing
After constructing the hypergraph, the HyperCompute module performs two-stage message passing. First, the input feature $X$ is transformed by a learnable linear mapping:
$$ \tilde{X} = XW, \quad W \in \mathbb{R}^{C \times C} $$
The incidence matrix is normalized to obtain a weight matrix:
$$ P_{ij} = \frac{H_{ij}}{\sum_{k=1}^{N} H_{ik} + \delta} $$
where $\delta$ is a small constant for numerical stability. The first aggregation produces hyperedge representations:
$$ E = \mathrm{Agg}\left( H^T, \tilde{X} \right) $$
The second aggregation produces updated node representations:
$$ \hat{X} = \mathrm{Agg}\left( H, E \right) $$
Finally, a residual connection and batch normalization are applied:
$$ F_{\text{hyp}} = \phi\left( \mathrm{BN}\left( \hat{X} + X \right) \right) $$
The first message-passing stage retains the commonality of similar nodes and suppresses the accidental response of individual noisy nodes. The second stage allows each node to retain its original local representation while also receiving its hyperedge context. The residual connection is important because if the neighborhood relations are unreliable, the original feature can still pass through. This prevents over-smoothing of fine-grained objects. In UAV drone detection, over-smoothing is a real risk because small objects have limited spatial extent. A relation module that averages too aggressively can erase the very features that distinguish a small object from its background.
| Stage | Formula | Function |
|---|---|---|
| Linear transform | $\tilde{X} = XW$ | Project node features into relation space |
| Normalization | $P_{ij} = H_{ij} / (\sum_k H_{ik} + \delta)$ | Prevent hyperedge size bias |
| Hyperedge aggregation | $E = \mathrm{Agg}(H^T, \tilde{X})$ | Form group-level representations |
| Node aggregation | $\hat{X} = \mathrm{Agg}(H, E)$ | Return group context to each node |
| Residual | $F_{\text{hyp}} = \phi(\mathrm{BN}(\hat{X}+X))$ | Preserve local detail and stabilize training |
Why Hypergraph Is Suitable for UAV Drone Detection
A standard graph connects two nodes at a time. A hypergraph connects a set of nodes through a hyperedge. This distinction matters for UAV drone scenes because objects often appear in groups. Cars appear in queues, pedestrians appear in crowds, and small vehicles appear in parking lots. The relation among a group is not fully captured by a collection of pairwise edges. A hyperedge can represent a shared context region, and the message passing can aggregate evidence from multiple similar nodes. When one node is weak because of occlusion or low contrast, the hyperedge can still provide a stable group-level signal. This is especially useful for small objects, where individual node responses are unreliable.
At the same time, hypergraph computation must be controlled. If every node were connected to every other node, the hypergraph would become a dense global attention mechanism with high computational cost and high risk of background propagation. The distance threshold $\epsilon$ prevents this. It restricts hyperedges to feature-space neighborhoods. In my design, the hypergraph is not a replacement for local convolution. It is a complementary high-order context module that operates on aligned nodes.
MutualGuideFusion
The third component is MutualGuideFusion. The hypergraph encoder produces a context-enhanced feature on the P4 grid. However, detection still requires both the localization detail of P4 and the semantic discrimination of P5. If the context feature is simply passed to the decoder, the decoder may lose the fine-grained information that is needed for precise box regression. Conversely, if the context feature is not used at all, the high-order relations computed by the hypergraph are wasted. MutualGuideFusion addresses this gap by performing bidirectional information exchange between the context-enhanced feature and the detection-scale features.
The module first aligns the channel dimensions of the two input features using $1\times1$ convolutions:
$$ P_i’ = \mathrm{Conv}_{1\times1}(P_i) $$
It then applies squeeze-and-excitation attention to recalibrate channel responses:
$$ P_i” = \mathrm{SEAttention}(P_i’) $$
The SE attention computes global average pooling, a bottleneck transformation, and a sigmoid gate. It emphasizes channels that are relevant to the target and suppresses channels that are dominated by background. This is important in UAV drone imagery because background textures such as roofs and roads can activate many channels. Channel recalibration provides a lightweight way to reduce their influence.
The recalibrated features are then combined through bidirectional guidance:
$$ P_{\text{fused}}^{(i)} = P_i” \otimes P_i $$
$$ F_{\text{out}} = \mathrm{Conv}_{1\times1}(P_{\text{fused}}) $$
In practice, the bidirectional exchange means that the P4 branch receives high-level semantic context from the P5 branch, while the P5 branch receives fine spatial structure from the P4 branch. The high-level context helps suppress background responses in P4 that resemble small objects. The fine spatial structure helps prevent P5 from becoming too abstract and losing small-object localization. This mutual guidance is more effective than a one-way top-down or bottom-up fusion because it allows each scale to correct the failure mode of the other.
| Operation | Formula | Effect |
|---|---|---|
| Channel alignment | $P_i’ = \mathrm{Conv}_{1\times1}(P_i)$ | Match channel dimensions |
| SE recalibration | $P_i” = \mathrm{SEAttention}(P_i’)$ | Emphasize target channels and suppress background |
| Bidirectional weighting | $P_{\text{fused}}^{(i)} = P_i” \otimes P_i$ | Exchange complementary information |
| Output projection | $F_{\text{out}} = \mathrm{Conv}_{1\times1}(P_{\text{fused}})$ | Produce fused detection-scale features |
In the full LHM-DEIM pipeline, MutualGuideFusion plays a specific role. HyperCompute produces group-level context on the aligned P4 grid. MutualGuideFusion then feeds that context back to the detection scales. Without this feedback, the context would remain in the encoder and would not directly influence the final predictions. The ablation results confirm this. Adding MutualGuideFusion alone improves AP0.5 by 1.0 percentage point with only a small parameter increase. When combined with LoGStem and H-HEN, the full model achieves the best performance.
Training Objective
I train LHM-DEIM with a standard detection loss composed of classification, box regression, and generalized IoU terms. The classification branch uses a focal-style objective to handle the foreground-background imbalance that is severe in UAV drone images. The box regression branch uses L1 loss and GIoU loss. The overall objective can be written as:
$$ \mathcal{L} = \lambda_{\text{cls}} \mathcal{L}_{\text{cls}} + \lambda_{\text{L1}} \mathcal{L}_{\text{L1}} + \lambda_{\text{GIoU}} \mathcal{L}_{\text{GIoU}} $$
I do not change the baseline matching mechanism. DEIM is used with its improved matching strategy, and DFINE provides fine-grained distribution refinement for box regression. The contribution of my work is in the representation and fusion path, not in the assignment strategy. This separation is useful because it shows that the proposed modules improve performance even when the matching and regression mechanisms are held constant.
Experimental Setup
I use VisDrone2019 as the primary benchmark. It contains 10,209 static images, split into 6,471 training images, 548 validation images, and 3,190 test images. The images are captured by UAV drone cameras in diverse real-world scenes. Small objects account for a large proportion of the dataset, and heavy occlusion is common. This makes VisDrone2019 a suitable testbed for my method. I also use UAVDT for generalization. UAVDT contains 40,735 high-resolution images, with 24,143 for training and 16,592 for validation. It covers sedan, bus, and truck categories and includes varying altitude, viewpoint, weather, and illumination conditions.
All models are implemented with PyTorch 2.3.0, CUDA 12.1, Python 3.10.16, and Torchvision 0.18.0. Training is performed on an RTX4090 GPU with 24 GB memory. Images are resized to $640\times640$. The batch size is 4. The initial learning rate is $10^{-4}$. I use FP32 precision and do not enable automatic mixed precision. The reason is that HyperCompute constructs discrete hyperedges based on Euclidean distances and a fixed threshold $\epsilon$. Numerical rounding near the threshold could change the connectivity pattern in mixed precision. To control this potential numerical factor and maintain fair comparison, I keep FP32 training for all experiments, including ablation, threshold sensitivity, and generalization.
| Dataset | Training images | Validation images | Test images | Main characteristics |
|---|---|---|---|---|
| VisDrone2019 | 6,471 | 548 | 3,190 | Small objects, dense scenes, occlusion, urban and rural backgrounds |
| UAVDT | 24,143 | 16,592 | — | Vehicles, weather and illumination variation, multiple altitudes |
| Setting | Value |
|---|---|
| Input size | $640 \times 640$ |
| Batch size | 4 |
| Initial learning rate | $10^{-4}$ |
| Precision | FP32 |
| GPU | RTX4090 24 GB |
| Framework | PyTorch 2.3.0, CUDA 12.1 |
| Baseline | DEIM-DFINE |
Ablation Study
I perform an ablation study on VisDrone2019 to isolate the effect of each proposed module. The baseline is DEIM-DFINE. I report AP0.5, AP, APs, and parameter count. The results are summarized in Table 8.
| Setting | LoGStem | H-HEN | MutualGuideFusion | AP0.5 / % | AP / % | APs / % | Params / M |
|---|---|---|---|---|---|---|---|
| Baseline | — | — | — | 34.3 | 19.3 | 12.3 | 3.73 |
| 1 | Yes | — | — | 35.1 | 19.6 | 12.9 | 3.76 |
| 2 | — | Yes | — | 36.2 | 20.1 | 13.5 | 3.83 |
| 3 | — | — | Yes | 35.3 | 19.8 | 12.9 | 3.74 |
| 4 | Yes | Yes | — | 37.3 | 20.5 | 13.7 | 3.86 |
| 5 | Yes | — | Yes | 35.7 | 19.7 | 13.1 | 3.78 |
| 6 | — | Yes | Yes | 36.7 | 20.9 | 13.9 | 3.85 |
| 7 | Yes | Yes | Yes | 38.2 | 21.6 | 14.8 | 3.89 |
The baseline achieves 34.3% AP0.5, 19.3% AP, and 12.3% APs. Adding LoGStem alone improves AP0.5 by 0.8 percentage points and AP by 0.3 percentage points. This confirms that early edge enhancement and noise suppression help the model preserve small-object evidence. Adding H-HEN alone improves AP0.5 by 1.9 percentage points and AP by 0.8 percentage points. This larger gain reflects the combined effect of spatial alignment and high-order context. Adding MutualGuideFusion alone improves AP0.5 by 1.0 percentage point with only a 0.01M increase in parameters. When all three modules are used, the model achieves 38.2% AP0.5, 21.6% AP, and 14.8% APs. The full model improves AP0.5 by 3.9 percentage points and APs by 2.5 percentage points over the baseline, while the parameter count increases from 3.73M to 3.89M, an increase of about 4.3%.
I also perform a detailed ablation of H-HEN to understand the contribution of SSA and HyperCompute. The results are shown in Table 9.
| Model | AP0.5 / % | AP / % | APs / % | Params / M |
|---|---|---|---|---|
| Baseline | 34.3 | 19.3 | 12.3 | 3.73 |
| SSA only | 35.2 | 19.6 | 12.9 | 3.76 |
| HyperCompute only | 35.4 | 19.9 | 13.1 | 3.81 |
| H-HEN (SSA + HyperCompute) | 36.2 | 20.1 | 13.5 | 3.83 |
SSA alone improves AP0.5 by 0.9 percentage points. This shows that aligning P2 through P5 to a common P4 grid reduces scale mismatch. HyperCompute alone improves APs to 13.1%, which indicates that high-order context is particularly useful for small objects. When SSA and HyperCompute are combined, AP0.5 reaches 36.2% and AP reaches 20.1%. The combination is better than either component alone because hypergraph message passing benefits from spatially aligned nodes. The additional parameter cost of H-HEN is only about 2.7% relative to the baseline, which is modest for the observed gain.
Sensitivity to the Hypergraph Threshold
The hypergraph threshold $\epsilon$ is a key hyperparameter. I evaluate five candidate values: 64, 96, 128, 160, and 192. All other settings are kept identical. The results are reported in Table 10.
| $\epsilon$ | AP0.5 / % | AP / % | APs / % |
|---|---|---|---|
| 64 | 36.4 | 19.9 | 13.2 |
| 96 | 37.8 | 20.9 | 13.9 |
| 128 | 38.2 | 21.6 | 14.8 |
| 160 | 37.6 | 20.7 | 13.4 |
| 192 | 36.6 | 19.8 | 13.3 |
The performance first increases and then decreases as $\epsilon$ grows. When $\epsilon$ is too small, the hyperedges cover too few nodes, and the model cannot exploit high-order context. When $\epsilon$ is too large, weakly related nodes and background nodes are included in the same hyperedge, which introduces relation noise. The best result is obtained at $\epsilon=128$, with 38.2% AP0.5, 21.6% AP, and 14.8% APs. The decline in APs at larger thresholds is more pronounced, which suggests that extremely small objects are more sensitive to background noise entering the hyperedge. This supports the idea that locality control is essential for UAV drone detection.
Comparison with Other Detectors
I compare LHM-DEIM with representative two-stage, one-stage, transformer-based, and real-time detectors. The comparison includes Faster R-CNN-R50, Cascade R-CNN-R50, DINO, YOLOv8, YOLOv11, YOLOv12, FBRT-YOLO-S, YOLO26, RT-DETR-R18, RT-DETRv2-R18, and two same-baseline improved models. The results are summarized in Table 11. I report AP, AP0.5, APs, APm, APl, parameter count, GFLOPs, and FPS where available.
| Model | AP / % | AP0.5 / % | APs / % | APm / % | APl / % | Params / M | GFLOPs | FPS |
|---|---|---|---|---|---|---|---|---|
| Faster R-CNN-R50 | 19.4 | 32.9 | 9.5 | 30.9 | 42.9 | 41.39 | 208 | — |
| Cascade R-CNN-R50 | 19.7 | 32.6 | 9.9 | 30.9 | 40.6 | 69.29 | 236 | — |
| DINO | 25.3 | 44.5 | 15.1 | 37.1 | 50.3 | 47.56 | 274 | — |
| YOLOv8n | 19.2 | 32.3 | 9.9 | 28.8 | 33.9 | 3.1 | 8.1 | 86 |
| YOLOv8s | 21.4 | 37.6 | 12.3 | 30.3 | 36.2 | 11.13 | 28.5 | 51 |
| YOLOv11n | 19.3 | 31.3 | 9.7 | 27.9 | 33.6 | 2.59 | 6.3 | 94 |
| YOLOv11s | 21.6 | 38.4 | 12.6 | 31.2 | 36.2 | 9.42 | 21.3 | 56 |
| YOLOv12n | 19.2 | 31.4 | 9.6 | 27.7 | 34.6 | 2.56 | 6.3 | — |
| YOLOv12s | 21.5 | 38.6 | 12.4 | 30.8 | 35.8 | 9.23 | 21.2 | — |
| FBRT-YOLO-S | 20.3 | 36.9 | 11.8 | 29.6 | 35.3 | 2.9 | 22.9 | — |
| YOLO26s | 18.8 | 35.6 | 10.8 | 29.2 | 34.9 | 9.47 | 20.5 | — |
| RT-DETR-R18 | 21.3 | 38.9 | 13.9 | 28.5 | 38.3 | 20 | 60 | — |
| RT-DETRv2-R18 | 22.2 | 40.1 | 13.7 | 32.1 | 40.1 | 20 | 60 | — |
| Same-baseline improved model A | 19.5 | 33.9 | 11.3 | 32.7 | 39.6 | 3.87 | 7.06 | — |
| Same-baseline improved model B | 23.5 | 40.5 | 14.8 | 34.6 | 48.9 | 11.87 | 34.1 | — |
| LHM-DEIM | 21.6 | 38.2 | 14.8 | 31.3 | 36.9 | 3.89 | 16.4 | 54 |
LHM-DEIM achieves 21.6% AP and 38.2% AP0.5. It is competitive with several larger models. Its APs is 14.8%, which matches the strongest small-object result among the same-baseline improved models and exceeds RT-DETR-R18 and RT-DETRv2-R18. DINO reaches higher overall AP, but it uses 47.56M parameters and 274 GFLOPs. In contrast, LHM-DEIM uses only 3.89M parameters and 16.4 GFLOPs. This is a much better fit for UAV drone edge deployment. Compared with SCA-DEIM-N, LHM-DEIM improves AP, AP0.5, and APs by 2.1, 4.3, and 3.5 percentage points, respectively, with nearly the same parameter count. Compared with HMF-DEIM, LHM-DEIM has 1.9 percentage points lower overall AP but the same APs, while reducing parameters by about 67.2% and computation by about 51.9%. This trade-off is favorable for real-time UAV drone perception, where payload and power are constrained.
I also evaluate embedded inference on a Jetson Orin Nano 4 GB platform using TensorRT 8.6.2, FP16 precision, $640\times640$ input, and batch size 1. Under these conditions, LHM-DEIM reaches 54 FPS. This is slightly lower than the lightest YOLO variants but comparable to YOLOv8s and YOLOv11s, while providing higher APs. The result indicates that the proposed model can support real-time UAV drone detection in practical edge scenarios.
| Model | AP0.5 / % | APs / % | Params / M | GFLOPs | Embedded FPS |
|---|---|---|---|---|---|
| YOLOv8n | 32.3 | 9.9 | 3.1 | 8.1 | 86 |
| YOLOv8s | 37.6 | 12.3 | 11.13 | 28.5 | 51 |
| YOLOv11n | 31.3 | 9.7 | 2.59 | 6.3 | 94 |
| YOLOv11s | 38.4 | 12.6 | 9.42 | 21.3 | 56 |
| LHM-DEIM | 38.2 | 14.8 | 3.89 | 16.4 | 54 |
Visualization and Qualitative Behavior
I visualize detection results and response maps for several challenging UAV drone scenes. The scenes include daytime streets, dense parking lots, and nighttime roads. In the daytime street and parking lot scenes, the baseline model produces many missed detections, especially in building shadows and distant regions. LHM-DEIM reduces these missed detections substantially and captures many extremely small objects. In nighttime scenes, the model maintains a high recall and stable localization under strong illumination variation.
The response maps show a similar pattern. The baseline produces scattered activation, with energy spread across background regions. LHM-DEIM produces more concentrated activation at object centers. Background interference is suppressed. For distant tiny objects, the baseline response sometimes disappears, while LHM-DEIM still produces a clear and isolated activation. This indicates that the proposed modules improve feature integration in sparse-evidence regions.
I also examine three difficult conditions: extremely small objects, heavy occlusion, and strong fog. In the extremely small object scene, the baseline has broad scattered responses over vegetation and non-target regions. LHM-DEIM concentrates its response on roads, vehicles, and dense target areas. In the heavy occlusion scene, both models focus on the main target regions, but LHM-DEIM generates more continuous responses in dense areas and maintains attention on partially occluded objects. In the strong fog scene, image contrast is low and object texture is severely degraded. The baseline produces many low-confidence candidate boxes. LHM-DEIM is more conservative and focuses on regions with identifiable features. It reduces uncertain background responses but still misses some objects. This shows that extreme weather remains a difficult condition and is a direction for future improvement.
| Scene | Baseline behavior | LHM-DEIM behavior |
|---|---|---|
| Daytime street | Missed detections in shadows and distant regions | Higher recall for small vehicles and pedestrians |
| Dense parking lot | Scattered responses and missed tiny objects | Concentrated responses and better small-object capture |
| Night road | Unstable localization under illumination changes | Stable recall and improved localization |
| Heavy occlusion | Fragmented responses in dense groups | More continuous group responses |
| Strong fog | Many low-confidence boxes | More conservative predictions, still some misses |
Generalization on UAVDT
I evaluate generalization on UAVDT. The baseline and LHM-DEIM are trained and evaluated under the same protocol. The results are shown in Table 14.
| Model | AP / % | AP0.5 / % | APs / % | APm / % | APl / % | Params / M |
|---|---|---|---|---|---|---|
| Baseline | 19.1 | 32.1 | 14.8 | 28.1 | 30.3 | 3.73 |
| LHM-DEIM | 20.9 | 34.9 | 15.3 | 31.0 | 31.4 | 3.89 |
LHM-DEIM improves AP by 1.8 percentage points, AP0.5 by 2.8 percentage points, and APs by 0.5 percentage points. The gains in APm and APl are also positive. The parameter increase is only 0.16M. This supports the claim that the proposed design generalizes beyond the primary dataset. The improvement in medium and large objects indicates that the model does not sacrifice larger-scale performance to improve small objects. Instead, the cross-scale alignment and mutual guidance produce balanced gains.
Discussion
The results support a coherent interpretation. LoGStem improves node reliability at the front end. H-HEN aligns nodes and aggregates high-order context. MutualGuideFusion returns that context to the detection scales. The modules are not independent. The ablation shows that combinations outperform individual modules. For example, LoGStem and H-HEN together achieve 37.3% AP0.5, which is higher than either module alone. This is consistent with the role of LoGStem in providing cleaner edges for hypergraph distance computation. Similarly, H-HEN and MutualGuideFusion together achieve 36.7% AP0.5, which is higher than H-HEN alone. This is consistent with the role of MutualGuideFusion in feeding hypergraph context back to the decoder.
The threshold sensitivity analysis shows that relation locality is important. A hypergraph with too small a radius cannot gather enough context. A hypergraph with too large a radius includes background nodes and degrades small-object precision. The best threshold in my experiments is 128, but I do not treat this as a universal constant. It depends on the feature scale, dataset, and training configuration. A future extension could learn the threshold adaptively from local feature density, prediction uncertainty, or task loss.
The comparison with other detectors shows that LHM-DEIM is not the absolute accuracy leader. DINO achieves higher AP but at a much larger computational cost. My design targets a different operating point: strong small-object detection with low parameter count and moderate computation. In UAV drone applications, this operating point is often more valuable than maximum accuracy on a large GPU. The embedded FPS result supports this view. The model reaches 54 FPS on a Jetson Orin Nano 4 GB platform, which is sufficient for many real-time UAV drone perception tasks.
There are limitations. The hypergraph uses a fixed distance threshold, which may not adapt to all image degradation levels, object densities, or feature distributions. The choice of P4 as the alignment scale is static. While P4 balances detail and semantics, it may not be optimal for extreme small or extreme large objects. LoG enhancement is helpful for weak edges, but in strong noise or severe blur, a more robust degradation-aware mechanism may be needed. The spatial scale alignment also needs more validation under extreme occlusion and ultra-small object localization. These limitations point to clear future directions.
Future Work
I plan to extend the framework in several directions. First, I will investigate adaptive hypergraph thresholds. Instead of using a fixed $\epsilon$, the model could estimate the threshold from local feature density, predicted uncertainty, or a learned gating function. This would allow the hypergraph to adjust its locality radius for different UAV drone scenes. Second, I will explore dynamic alignment scales. Instead of always aligning to P4, the model could select or fuse P3, P4, and P5 based on the target scale distribution. Third, I will jointly model LoG edge enhancement and image degradation. A quality-aware module could estimate noise and blur levels and adjust the strength of high-frequency enhancement accordingly. Fourth, I will investigate quantization, pruning, and distillation to further reduce computation for edge deployment. Finally, I will evaluate the method on more diverse UAV drone datasets, including thermal imagery, nighttime surveillance, and adverse weather, to test robustness beyond the current benchmarks.
Conclusion
I have presented LHM-DEIM, a UAV drone object detection framework built on DEIM-DFINE. The method combines LoGStem, H-HEN, and MutualGuideFusion to address early texture loss, cross-scale spatial inconsistency, unreliable relation propagation, and deep feature attenuation. LoGStem uses a Laplacian-of-Gaussian edge prior and Gaussian residual to improve shallow node reliability. H-HEN uses spatial scale alignment to map P2 through P5 to a common P4 grid and builds a hypergraph to aggregate high-order context. MutualGuideFusion returns the context to the detection scales through channel recalibration and bidirectional guidance. On VisDrone2019, the full model improves AP0.5 from 34.3% to 38.2% and APs from 12.3% to 14.8%, with only a 4.3% parameter increase. On UAVDT, it improves AP from 19.1% to 20.9% and AP0.5 from 32.1% to 34.9%. The results show that a carefully designed combination of edge-aware stem processing, scale alignment, hypergraph context, and mutual guidance can deliver a strong accuracy-efficiency balance for UAV drone detection. The method is suitable for edge deployment and provides a foundation for future work on adaptive thresholds, dynamic scale selection, degradation-aware enhancement, and further lightweight optimization.
| Component | Primary role | Key mechanism | Observed benefit |
|---|---|---|---|
| LoGStem | Reliable shallow representation | LoG edge prior, Gaussian residual, DRFD | +0.8 AP0.5 alone; improves node separability |
| H-HEN | Cross-scale alignment and high-order context | SSA, hypergraph construction, HyperCompute | +1.9 AP0.5 alone; strong APs gain |
| MutualGuideFusion | Context feedback to detection scales | SE attention, bidirectional guidance | +1.0 AP0.5 alone; low parameter cost |
| Full LHM-DEIM | Balanced UAV drone detection | Closed-loop detail-context integration | +3.9 AP0.5, +2.5 APs, +4.3% params |
In summary, my work shows that improving UAV drone detection requires more than adding capacity or attention. It requires controlling the quality of the nodes, the geometry of their comparison, the locality of their relations, and the path by which context returns to the prediction scales. LHM-DEIM is designed around these principles, and the experimental results confirm that this design leads to consistent gains in small-object detection while maintaining a compact and deployable model.