Lightweight aviation image vehicle detection method based on YOLOv11 architecture
By introducing the RxDF, LiteFPP, and CRDown modules into the YOLOv11 architecture, the problems of high computational overhead and poor performance in detecting small vehicles in aerial imagery vehicle detection are solved, enabling efficient and accurate detection on UAV platforms.
Patent Information
- Application Number
- CN202510713834.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-05-30
- Publication Date
- 2025-09-12
AI Technical Summary
Existing aerial image vehicle detection models have high computational overhead, poor small vehicle detection performance, and low efficiency in multi-scale feature fusion, making it difficult to achieve high-precision real-time detection on resource-constrained platforms such as drones.
A lightweight aerial image vehicle detection method based on the YOLOv11 architecture is adopted. The residual cross depth fusion module (RxDF), the lightweight feature pyramid pooling module (LiteFPP) and the channel compression downsampling module (CRDown) are introduced to improve detection accuracy and reduce model complexity.
Accurate real-time detection of small and dense vehicles is achieved in complex aerial scenes, which is suitable for drones and embedded systems, reducing the number of model parameters and computational overhead.
Smart Images
Figure CN120635734A_ABST
Abstract
Description
Technical Field
[0001] The present invention belongs to the technical field of computer vision and remote sensing image processing, and specifically relates to a lightweight deep learning method for vehicle detection. Background Art
[0002] In recent years, vehicle detection in aerial imagery has become a core task in Intelligent Transportation Systems (ITS), particularly for applications such as drones, unmanned aerial vehicles (UAVs), and satellite imagery. Current mainstream approaches rely primarily on deep learning-based object detectors, particularly the YOLO family of models, such as YOLOv5, YOLOv6, YOLOv8, and YOLOv9. These models offer strong end-to-end performance, but they incur high computational overhead due to their complex modular design, which typically includes multi-branch architectures, attention mechanisms, and Transformer-based feature extractors.
[0003] To improve the detection performance of small objects in aerial imagery, various improved models have been proposed. For example, AFRE-Net employs a fine-grained feature pyramid to suppress background interference and enhance feature representation; R-YOLOv5 integrates the SwinTransformer block with the Adaptive Spatial Feature Fusion (ASFF) mechanism to improve robustness in dense scenes; TIOE-Det introduces a Posterior Hierarchical Alignment (PHA) module to enhance localization accuracy; and LC-YOLO achieves finer feature extraction from shallow features through cross-layer attention upsampling and a Laplacian bottleneck module. Although these methods have achieved improvements in detection accuracy, most still suffer from large parameter counts and slow inference speed, making them difficult to apply to resource-constrained platforms such as embedded systems or drones.
[0004] Furthermore, detecting small vehicles in aerial imagery still faces numerous challenges. These include scale shifts and perspective distortion caused by varying shooting altitudes and angles, as well as complex backgrounds, densely packed objects, and partial occlusions, which can further impact detection. While multi-scale feature fusion modules (such as SPPF, PAN, and FPN) are widely used to improve performance, these modules often introduce redundant computations and structural complexity, hindering real-time performance.
[0005] Currently, there is no unified neural network architecture that can simultaneously achieve high detection accuracy for small vehicles in aerial imagery, maintain low parameter count and low GFLOPs, and maintain stable performance on multiple different datasets (such as UCAS_AOD, VEDAI, UAVDT, and UAV-ROD). Summary of the Invention
[0006] This paper aims to address key challenges in aerial vehicle detection, including the high computational overhead of existing models, poor detection performance for small or rotated vehicles, and low efficiency of multi-scale feature fusion. To overcome these difficulties, this paper proposes a lightweight aerial image vehicle detection method based on the YOLOv11 architecture. It innovatively introduces three new modules: the Residual Cross-Deep Fusion module (RxDF), the Lightweight Feature Pyramid Pooling module (LiteFPP), and the Channel Compression Downsampling module (CRDown). This significantly reduces model complexity while improving detection accuracy, enabling accurate and real-time vehicle detection in complex aerial scenarios. It is suitable for deployment on drones and other resource-constrained devices.
[0007] To achieve the above object, the present invention provides the following technical solutions:
[0008] A lightweight vehicle detection method for aerial images based on the YOLOv11 architecture includes the following steps:
[0009] Step 1: Image input
[0010] The remote sensing image of the drone to be detected is used as the model input;
[0011] Step 2: Image preprocessing
[0012] Preprocess the image and use the result as input for the subsequent feature extraction network;
[0013] Step 3: Backbone feature extraction
[0014] After preprocessing, the image is input into the improved backbone network based on YOLOv11, which uses the residual cross-depth fusion (RxDF) module for feature extraction. Specifically,
[0015] 3.1. Channel compression: Use 1×1 convolution to compress the input channel number C_in to C_hidden, (expansion = 0.5), where: C_hidden represents the number of channels in the hidden layer, that is, the number of channels in the middle layer, C_out represents the number of channels in the output layer, and expansion is the expansion factor;
[0016] 3.2. Bottleneck Block: Connect one bottleneck block at a time. Each bottleneck block consists of two separable depthwise convolutions. First, a 3×1 convolution is performed to extract horizontal features, and then a 1×3 convolution is performed to extract vertical features.
[0017] 3.3. Feature concatenation and aggregation: After concatenating the original output with the output of each bottleneck block along the channel dimension, 1×1 convolution is used to aggregate features and compress the channels to obtain the fused feature map Y_agg;
[0018] 3.4. Channel Attention Enhancement (CFAg Module): Use the CFAg module to enhance the channel dimension of Y_agg;
[0019] 3.5. Normalization and Activation: The final output is activated by BatchNorm and SiLU to obtain the output Y after feature extraction;
[0020] Step 4: Channel compression and downsampling
[0021] The channel compression downsampling (CRDown) module is introduced in the backbone P5 layer, and its structure is as follows:
[0022] 4.1 Channel Compression: The input feature map X first undergoes a 1×1 convolution to reduce the number of channels from C1 to
[0023] pressure
[0024] Shrink to C2;
[0025] 4.2 Spatial downsampling: The spatial dimension is downsampled by 3×3 depthwise separable convolution, and the output size is
[0026] Step 5: Lightweight Feature Pyramid Pooling (LiteFPP module)
[0027] 5.1 Multi-scale pooling operation: Two types of maximum pooling are performed on the input feature map:
[0028] 5.2 Feature splicing and fusion: After splicing the original feature map with the two pooling results, 1×1 convolution is used for channel fusion to output an enhanced context-aware feature map;
[0029] Step 6: Detection Head
[0030] Step 7: Decoding and Reasoning
[0031] Step 8: Training and loss function
[0032] Step 9: Post-processing
[0033] The candidate bounding boxes output by the detection head are filtered to remove duplicate and low-confidence detection results and improve detection accuracy.
[0034] Furthermore, the specific implementation process of step 3.1 is as follows:
[0035] enter
[0036] Where: represents the set of real numbers, C in ×H×W represents the dimension of the tensor, specifically: C inis the number of input channels, H is the height of the feature map (number of pixels), and W is the width of the feature map (number of pixels);
[0037] Channel Compression:
[0038] F0=X*W split +b split (1)
[0039] Where: F0 represents the output feature after linear transformation, W split is the weight matrix, b split is the bias vector.
[0040] Furthermore, the specific implementation process of step 3.2 is as follows:
[0041] Processed by each bottleneck block:
[0042] F i =F i-1 *W dw1 (i) +b dw1 (i) (2)
[0043] F i =F i *W dw2 (i) +b dw2 (i) (3)
[0044] Where: F i represents the output feature map of the i-th layer, F i-1 Represents the input feature map of the previous layer (i-1 layer), W dw1 (i) represents the depth convolution weight of layer i, b dw1 (i) represents the depth convolution bias of the i-th layer;
[0045] Feature stitching:
[0046] C=Concat(F0,F1,...,F n ) (4)
[0047] Where: C represents the concatenated output tensor, Concat(.) represents the concatenation function, which connects multiple tensors in the specified dimension.
[0048] Furthermore, the feature aggregation calculation formula in step 3.3 is:
[0049] Feature aggregation:
[0050] Y agg =C*W agg +bagg (5)
[0051] Where: W agg represents the convolution kernel, b agg Represents the bias vector.
[0052] Furthermore, the calculation formula for outputting Y in step 3.5 is:
[0053] Add attention and activation functions:
[0054] Y final =σ(BN(CFAg(Y agg ))) (6)
[0055] Where: σ(·) is the activation function; BN(·) is batch normalization, and CFAg(·) is channel attention aggregation.
[0056] Furthermore, the specific implementation process of step 4 is as follows:
[0057] enter
[0058] Channel Compression:
[0059] X1=σ(X*W1+b1) (7)
[0060] Where: X1 represents the output feature of the layer, W1 represents the convolution kernel, and b1 represents the bias vector;
[0061] Spatial downsampling (depthwise convolution):
[0062]
[0063] Furthermore, the specific implementation process of step 5.1 is as follows:
[0064] 5×5 convolution kernel, padding=2;
[0065] 9×9 convolution kernel, padding=4;
[0066] Multi-scale pooling:
[0067] P1=MaxPool(X,k=5,s=1,p=2) (9)
[0068] P2=MaxPool(X,k=9,s=1,p=4) (10)
[0069] Where: P represents the output feature map after pooling, MaxPool(.) represents the maximum pooling function, k represents the pooling kernel size, s represents the step size, and p represents padding.
[0070] Furthermore, the specific implementation process of step 5.2 is as follows:
[0071] Splicing:
[0072] C = Concat(X, P1, P2) (11)
[0073] Fusion:
[0074] Y = C * W fuse + b fuse (12).
[0075] Furthermore, the specific processing flow of step six is as follows:
[0076] Classification branch using Sigmoid activation;
[0077] Use distributed regression branch with RegMax=16;
[0078] Each position outputs 4×16+nc channels.
[0079] Furthermore, the specific processing flow of step seven is as follows:
[0080] Decode the distribution predictions using the expected value method:
[0081] d = ∑j = 0 pj.j (13)
[0082] The classification score uses Sigmoid activation;
[0083] Calculate bounding box coordinates in conjunction with the mesh center.
[0084] Furthermore, the specific implementation process of step eight is as follows:
[0085] The loss function inherits YOLOv11, including:
[0086] L total = w1 · L cls + w2 · L DFL + w3 · L IoU (14)
[0087] Where: L total Represents the total loss function, w represents the weight coefficient, L cls represents the classification loss,
[0088] L DFL represents the distribution focusing loss, L IoU represents the intersection-over-union loss.
[0089] Furthermore, the specific processing flow of step nine is as follows:
[0090] 9.1 Calculate the intersection over union (IoU) value between prediction boxes: Calculate the intersection over union (IoU) of all prediction boxes pairwise.
[0091] Ratio, used to measure the degree of overlap;
[0092] 9.2 Sort prediction boxes by confidence: Sort each prediction box from high to low based on its category confidence (obtained after Sigmoid activation);
[0093] 9.3 Set the threshold and perform non-maximum suppression (NMS): Set the NMS threshold N (for example, 0.5). If the IoU of two predicted boxes is greater than the threshold, the one with higher confidence is retained and the one with lower confidence is suppressed.
[0094] 9.4 Output the final detection results: retain the bounding box after NMS processing, and output the predicted category, bounding box coordinates and corresponding confidence score of each target.
[0095] Compared with the prior art, the present invention has the following beneficial effects:
[0096] The proposed lightweight vehicle detection method significantly improves detection accuracy for small and densely packed vehicles in complex aerial scenarios while maintaining real-time inference speed. By introducing the RxDF, LiteFPP, and CRDown modules, the method effectively reduces model parameters and computational overhead, enabling deployment in drones and embedded systems. It achieves efficient and accurate vehicle detection despite scale variations, target rotation, and background clutter, offering excellent technical efficiency and economic feasibility for applications such as intelligent transportation and aerial surveillance. BRIEF DESCRIPTION OF THE DRAWINGS
[0097] The drawings described herein are used to provide a further understanding of the embodiments of the present invention, constitute a part of this application, and do not constitute a limitation of the embodiments of the present invention. In the drawings:
[0098] Figure 1 This is the overall structure diagram of the model of the present invention.
[0099] Figure 2 This is the internal structure diagram of the RxDF module.
[0100] Figure 3 This is the internal structure diagram of the Bottleneck module.
[0101] Figure 4 This is the internal structure diagram of the CFAg module.
[0102] Figure 5 This is the internal structure diagram of the LiteFPP module.
[0103] Figure 6 This is the internal structure diagram of the CRDown module.
[0104] Figure 7 Visualization of the detection results of VDXNet, YOLOv10n, and YOLO11n on four data sets. DETAILED DESCRIPTION
[0105] In order to further illustrate the technical means and effects adopted by the present invention to achieve the predetermined purpose of the invention, the specific implementation methods, structures, features and effects of the present invention are described in detail below in conjunction with the accompanying drawings and preferred embodiments.
[0106] like Figure 1 As shown, the present invention provides a lightweight aerial image vehicle detection method based on the YOLOv11 architecture, which specifically includes the following steps:
[0107] Step 1: Image input
[0108] The drone remote sensing image to be detected is in RGB format and 640×640 dimensions, which is used as the model input.
[0109] Step 2: Image preprocessing
[0110] The image is preprocessed as follows:
[0111] · Random horizontal flip;
[0112] · Brightness, contrast, and saturation enhancement;
[0113] · Normalize pixel values;
[0114] · Resize the image to 640×640;
[0115] The results serve as input to the subsequent feature extraction network.
[0116] Step 3: Backbone feature extraction
[0117] The preprocessed image is input into the improved backbone network based on YOLOv11. The backbone introduces the RxDF module to replace the original C3k2 module of YOLOv11 to improve the feature expression ability of small objects.
[0118] RxDF module implementation details:
[0119] 3.1. Channel compression: Use 1×1 convolution to compress the input channel number C_in into C_hidden to facilitate subsequent lightweight calculations. (expansion = 0.5), where: C_hidden represents the number of channels in the hidden layer, that is, the number of channels in the middle layer, C_out represents the number of channels in the output layer, and expansion is the expansion factor, which is generally a value greater than 1. Its purpose is to increase the number of channels in the middle layer.
[0120] Implementation process:
[0121] enter
[0122] Where: represents the set of real numbers, C in ×H×W represents the dimension of the tensor, specifically: C in is the number of input channels, H is the height of the feature map (number of pixels), and W is the width of the feature map (number of pixels).
[0123] Channel Compression:
[0124] F0=X*W split +b split (1)
[0125] Where: F0 represents the output feature after linear transformation, W split is the weight matrix used to perform linear transformation on the input features, b split is a bias vector used to increase the expressive power of the model.
[0126] 3.2. Bottleneck Block: Connect one bottleneck block in turn. Each bottleneck block consists of two separable depth convolutions. First, perform 3×1 convolution to extract horizontal features, and then perform 1×3 convolution to extract vertical features. The structure is as follows Figure 3 shown.
[0127] Processed by each bottleneck block:
[0128] F i =F i-1 *W dw1 (i) +b dw1 (i) (2)
[0129] F i =F i *W dw2 (i) +b dw2 (i) (3)
[0130] Where: F i represents the output feature map of the i-th layer, F i-1 Represents the input feature map of the previous layer (i-1 layer), Wdw1 (i) represents the depth convolution weight of layer i, b dw1 (i) represents the depthwise convolution bias of layer i.
[0131] Feature stitching:
[0132] C=Concat(F0,F1,...,F n ) (4)
[0133] Where: C represents the concatenated output tensor, Concat(.) represents the concatenation function, which connects multiple tensors in the specified dimension.
[0134] 3.3. Feature concatenation and aggregation: After concatenating the original output with the output of each bottleneck block along the channel dimension, 1×1 convolution is used to aggregate features and compress the channels to obtain the fused feature map Y_agg;
[0135] Feature aggregation:
[0136] Y agg =C*W agg +b agg (5)
[0137] Where: W agg represents the convolution kernel, b agg Represents the bias vector.
[0138] 3.4. Channel Attention Enhancement (CFAg Module): Use CFAg module to enhance the channel dimension of Y_agg (see Figure 4 ),include:
[0139] Adaptive average pooling;
[0140] Two sequential 1×1 convolutions (with a ReLU activation in the middle);
[0141] Sigmoid activation outputs attention weights;
[0142] Multiply the original image channel by channel to obtain the weighted feature map.
[0143] 3.5. Normalization and Activation: The final output is activated by BatchNorm and SiLU to obtain the output Y after feature extraction.
[0144] Add attention and activation functions:
[0145] Y final =σ(BN(CFAg(Y agg ))) (6)
[0146] Where: σ(·) is the activation function; BN(·) is batch normalization, which is used to stabilize and accelerate training; CFAg(·) is channel attention aggregation, which enhances important channels in a weighted manner.
[0147] The overall structure of the RxDF module is as follows Figure 2 shown.
[0148] Step 4: Channel Compression Downsampling (CRDown Downsampling Submodule)
[0149] To replace the traditional 3×3 convolution downsampling operation, the CRDown module is introduced in the backbone P5 layer. Its structure is as follows (see Figure 6 ):
[0150] 4.1 Channel Compression: The input feature map X first undergoes a 1×1 convolution to compress the number of channels from C1 to C2.
[0151] 4.2 Spatial downsampling: The spatial dimension is downsampled by 3×3 depthwise separable convolution (group=C2, stride=s), and the output size is
[0152] 4.3 Module Features: Compared with standard convolution, this module can significantly reduce computational complexity while maintaining edge features, making it suitable for UAV real-time detection scenarios.
[0153] Implementation process:
[0154] enter
[0155] Channel Compression:
[0156] X1 = σ(X * W1 + b1) (7)
[0157] Where: X1 represents the output feature of the layer, W1 represents the convolution kernel, and b1 represents the bias vector.
[0158] Spatial downsampling (depthwise convolution):
[0159]
[0160] This module reduces GFLOPs and model size while maintaining the edge and silhouette features of the vehicle.
[0161] Step 5: Multi-scale context fusion (LiteFPP multi-scale fusion submodule)
[0162] In order to improve the multi-scale perception capability, the LiteFPP module is used to replace the traditional SPPF module (see Figure 5 ), the structure is as follows:
[0163] 5.1 Multi-scale pooling operation: Two types of maximum pooling are performed on the input feature map:
[0164] 5×5 convolution kernel, padding=2;
[0165] 9×9 convolution kernel, padding=4;
[0166] Multi-scale pooling:
[0167] P1 = MaxPool(X, k=5, s=1, p=2) (9)
[0168] P2 = MaxPool(X, k=9, s=1, p=4) (10)
[0169] Where: P represents the output feature map after pooling, MaxPool(.) represents the maximum pooling function, k represents the pooling kernel size, s represents the step size, and p represents padding.
[0170] 5.2 Feature splicing and fusion: After splicing the original feature map with the two pooling results, 1×1 convolution is used for channel fusion to output an enhanced context-aware feature map.
[0171] Splicing:
[0172] C = Concat(X, P1, P2) (11)
[0173] Fusion:
[0174] Y = C * W fuse + b fuse (12)
[0175] 5.3 Module Advantages: It retains multi-scale information while avoiding repeated calculations in SPPF, and has higher efficiency and lightness.
[0176] 5.4 This module reduces the number of parameters while maintaining context diversity and supports real-time reasoning.
[0177] Step 6: Detection Head (YOLOv11)
[0178] The detection head structure is consistent with YOLOv11:
[0179] Classification branch using Sigmoid activation;
[0180] Use distributed regression branch with RegMax=16;
[0181] Each position outputs 4×16+nc channels.
[0182] Step 7: Decoding and Reasoning
[0183] Decoding distribution predictions using the expected value method:
[0184] d = ∑ j＝0 p j.j (13)
[0185] The classification scores are activated using Sigmoid.
[0186] Calculate bounding box coordinates in conjunction with the mesh center.
[0187] Step 8: Training and loss function
[0188] The loss function inherits YOLOv11, including:
[0189] L total = w1 · L cls + w2 · L DFL + w3 · L IoU (14)
[0190] Where: L total Represents the total loss function, w represents the weight coefficient, L cls represents the classification loss,
[0191] L DFL represents the distribution focusing loss, L IoU represents the intersection-over-union loss.
[0192] Step 9: Post-processing (non-maximum suppression)
[0193] This step is to filter the candidate bounding boxes output by the detection head to remove duplicate and low-confidence detection results and improve detection accuracy. The specific processing flow is as follows:
[0194] 9.1 Calculate the intersection over union (IoU) value between prediction boxes: Calculate the intersection over union (IoU) of all prediction boxes pairwise.
[0195] Ratio, used to measure the degree of overlap;
[0196] 9.2 Sort prediction boxes by confidence: Sort each prediction box from high to low based on its category confidence (obtained after Sigmoid activation);
[0197] 9.3 Set the threshold and perform non-maximum suppression (NMS): Set the NMS threshold N (for example, 0.5). If the IoU of two predicted boxes is greater than the threshold, the one with higher confidence is retained and the one with lower confidence is suppressed.
[0198] 9.4 Output the final detection results: retain the bounding box after NMS processing, and output the predicted category, bounding box coordinates and corresponding confidence score of each target.
[0199] Step 10: Model training process (training optimization module)
[0200] The VDXNet model is trained using the PyTorch framework with the following configuration:
[0201] Optimizer: AdamW
[0202] Learning rate: 0.00167
[0203] Weight decay: 0.000468
[0204] Batch size: 12
[0205] · Maximum number of training rounds: 500 (using a 100-round patient early termination mechanism);
[0206] Step 11: Inference Acceleration and Deployment Optimization
[0207] To deploy on edge devices or drones, the model is optimized for FP16 precision using the TensorRT toolchain after training.
[0208] · Inference platform: Intel i9-14900HX + NVIDIA RTX 4090;
[0209] · Precision setting: FP16;
[0210] · Average inference time: 0.7ms;
[0211] · Measured frame rate: about 540FPS.
[0212] Step 12: Deploy the application scenario
[0213] The present invention is applicable to a variety of aviation monitoring and intelligent transportation scenarios, including:
[0214] · Urban road vehicle monitoring and control;
[0215] · highway traffic analysis;
[0216] · Parking lot area recognition and target detection;
[0217] · Real-time identification and statistics of drone platforms.
[0218] Experimental data:
[0219] To demonstrate the effectiveness of our lightweight aerial imagery vehicle detection method based on the YOLOv11 architecture (hereafter referred to as VDXNet), the following section details the dataset used, the training process, the contributions of each module, comparative benchmarks, inference acceleration, and performance visualization results.
[0220] 1) Performance evaluation on multiple datasets
[0221] The proposed method is evaluated on four public aerial image datasets: UCAS_AOD, VEDAI, UAVDT, and UAV-ROD. These datasets cover real-world scenarios such as urban traffic, highway monitoring, and multi-angle vehicle appearance.
[0222] The implementation details are as follows:
[0223] (1) All images were resized to 640×640 resolution;
[0224] (2) The model is implemented using PyTorch and trained using the AdamW optimizer. The hyperparameters are set as follows:
[0225] o Learning rate: 0.00167
[0226] Weight decay: 0.000468
[0227] o Batch size: 12
[0228] o Maximum number of training rounds: 500 (using 100 rounds of patient early termination mechanism)
[0229] (3) The classification loss function is cross entropy loss, and bounding box regression uses CIoU loss;
[0230] (4) No transfer learning or pre-trained weights were used; all models were trained from scratch on each dataset.
[0231] Table 1: VDXNet performance on various datasets
[0232] Dataset mAP@50 Inference time (ms) FPS Parameter quantity (M) GFLOPs UCAS AOD 96.3％ 0.7 539.97 1.608 5.9 VEDAI 66.0％ 1.5 491.82 1.610 5.9 UAVDT 98.9％ 0.4 524.56 1.608 5.9 UAV-ROD 99.0％ 0.7 522.88 1.608 5.9
[0233] The model achieves high detection accuracy while maintaining low computational complexity and is suitable for deployment on drones and embedded AI platforms.
[0234] 2) Module ablation experiment
[0235] To evaluate the independent contributions of each module of RxDF, CRDown, and LiteFPP, ablation experiments with gradual module replacement are performed on the UCAS_AOD dataset.
[0236] Experimental setup:
[0237] (1) Only one module is replaced at a time, and the rest remain unchanged;
[0238] (2) All experimental configurations use the same training conditions and input resolution;
[0239] (3) Use the mAP@50 indicator for evaluation.
[0240] Table 2: VDXNet module ablation experiment results (UCAS_AOD)
[0241]
[0242] Each module brings significant improvements in performance or complexity, and the complete VDXNet configuration achieves an optimal balance between accuracy and efficiency.
[0243] 3) Comparative analysis of each module
[0244] To further verify the effectiveness of each module, RxDF, LiteFPP, and CRDown are compared with their corresponding baseline modules (C3k2, SPPF, and standard Conv). All models are trained with the same hyperparameters, and the inference speed, mAP, and complexity metrics are recorded.
[0245] a.RxDF vs C3k2
[0246] RxDF outperforms C3k2 in terms of feature aggregation, computational efficiency, and feature selection. By introducing the bottleneck structure and CFAg attention mechanism, RxDF reduces complexity while enhancing feature expression capabilities.
[0247] Table 3: Performance comparison between RxDF and C3k2
[0248] Module mAP@50 Parameter quantity (million) GFLOPs Inference time (ms) C3K2 95.9％ 1.978 5.9 1.0 RxDF 96.3％ 1.608 5.9 0.7
[0249] b. LiteFPP vs. SPP LiteFPP adopts a multi-scale pooling strategy to replace the redundant fixed-core pooling method in SPPF, and combines it with lightweight Conv2D to achieve better feature fusion efficiency.
[0250] Table 4: LiteFPP and SPPF performance comparison
[0251] Module mAP@50 Parameter quantity (million) GFLOPs Inference time (ms) SPPF 96.2％ 1.576 5.9 0.8 LiteFPP 96.3％ 1.608 5.9 0.7
[0252] c. CRDown vs. Conv CRDown uses a two-step process of channel compression + spatial downsampling to more efficiently replace the traditional convolution operation and is particularly suitable for real-time processing requirements.
[0253] Table 5: Performance comparison between CRDown and Conv
[0254] Module mAP@50 Parameter quantity (million) GFLOPs Inference time (ms) Conv 95.9％ 1.998 6.1 1.0 CRDown 96.3％ 1.608 5.9 0.7
[0255] Each module brings quantifiable improvements to the model's lightweightness, inference efficiency, or accuracy.
[0256] 4) Comparative analysis with lightweight detection models
[0257] Using the same training and testing configurations, the proposed method is compared with other state-of-the-art lightweight detection models. VDXNet outperforms these models in terms of accuracy, efficiency, and inference speed, demonstrating significant technical and practical advantages.
[0258] Table 6: Performance comparison of VDXNet and other models
[0259]
[0260]
[0261] 5) Visual detection results under real aerial images
[0262] The detection results are visualized on real aerial images to evaluate the detection consistency of the model under small targets, occlusion and rotation. Figure 7 As shown in the figure, VDXNet generates tighter and more accurate bounding boxes. Other models often miss small vehicles or merge adjacent objects. VDXNet performs well in all scenarios, with no significant performance degradation.
[0263] In summary, the VDXNet model proposed in this paper provides an effective, lightweight, and high-speed solution for aerial vehicle detection. It combines architectural innovation with practical efficiency, has good embedded deployment capabilities, and is suitable for resource-constrained scenarios such as UAV platforms or edge AI devices.
[0264] The above description is merely a preferred embodiment of the present invention and does not constitute any form of limitation to the present invention. Although the present invention has been disclosed as above in terms of a preferred embodiment, it is not intended to limit the present invention. Any person skilled in the art can, without departing from the scope of the technical solution of the present invention, make some changes or modifications to equivalent embodiments using the technical contents disclosed above. However, any brief modifications, equivalent changes and modifications made to the above embodiments based on the technical essence of the present invention without departing from the content of the technical solution of the present invention are still within the scope of the technical solution of the present invention.
Claims
1. A lightweight vehicle detection method for aerial images based on the YOLOv11 architecture, characterized by: The specific steps include: Step 1: Image input The remote sensing image of the drone to be detected is used as the model input; Step 2: Image preprocessing Preprocess the image and use the result as input for the subsequent feature extraction network; Step 3: Backbone feature extraction After preprocessing, the image is input into the improved backbone network based on YOLOv11, which uses the residual cross-depth fusion module for feature extraction. Specifically, 3.
1. Channel compression: Use 1×1 convolution to compress the input channel number C_in to C_hidden, (expansion = 0.5), where: C_hidden represents the number of channels in the hidden layer, that is, the number of channels in the middle layer, C_out represents the number of channels in the output layer, and expansion is the expansion factor; 3.
2. Bottleneck module: Connect one bottleneck block in turn. Each bottleneck block consists of two separable depth convolutions. First, a 3×1 convolution is performed to extract horizontal features, and then a 1×3 convolution is performed to extract vertical features. 3.
3. Feature concatenation and aggregation: After concatenating the original output with the output of each bottleneck block along the channel dimension, 1×1 convolution is used to aggregate features and compress the channels to obtain the fused feature map Y_agg; 3.
4. Channel Attention Enhancement: Use CFAg module to enhance the channel dimension of Y_agg; 3.
5. Normalization and Activation: The final output is activated by BatchNorm and SiLU to obtain the output Y after feature extraction; Step 4: Channel compression and downsampling The channel compression downsampling module is introduced in the backbone P5 layer, and its structure is as follows: 4.1 Channel Compression: The input feature map X first undergoes a 1×1 convolution to compress the number of channels from C1 to C2; 4.2 Spatial downsampling: The spatial dimension is downsampled by 3×3 depthwise separable convolution, and the output size is Step 5: Lightweight Feature Pyramid Pooling 5.1 Multi-scale pooling operation: Two types of maximum pooling are performed on the input feature map: 5.2 Feature splicing and fusion: After splicing the original feature map with the two pooling results, 1×1 convolution is used for channel fusion to output an enhanced context-aware feature map; Step 6: Detection Head Step 7: Decoding and Reasoning Step 8: Training and loss function Step 9: Post-processing The candidate bounding boxes output by the detection head are filtered to remove duplicate and low-confidence detection results and improve detection accuracy.
2. A lightweight aerial image vehicle based on the YOLOv11 architecture as claimed in claim 1 vehicle The detection method is characterized in that: the specific implementation process of step 3.1 is: enter Where: represents the set of real numbers, C in ×H×W represents the dimension of the tensor, specifically: C in is the number of input channels, H is the height of the feature map (number of pixels), and W is the width of the feature map (number of pixels); Channel Compression: F0=X*W split +b split (1) Where: F0 represents the output feature after linear transformation, W split is the weight matrix, b split is the bias vector.
3. The lightweight vehicle detection method for aerial images based on the YOLOv11 architecture according to claim 2, wherein the specific implementation process of step 3.2 is as follows: Processed by each bottleneck block: F i =F i-1 *W dw1 (i) +b dw1 (i) (2) F i =F i *W dw2 (i) +b dw2 (i) (3) Where: F i represents the output feature map of the i-th layer, F i-1 Represents the input feature map of the previous layer (i-1 layer), W dw1 (i) represents the depth convolution weight of layer i, b dw1 (i) represents the depth convolution bias of the i-th layer; Feature stitching: C=Concat(F0,F1,...,F n ) (4) Where: C represents the concatenated output tensor, Concat(.) represents the concatenation function, which connects multiple tensors in the specified dimension.
4. A lightweight aerial image vehicle detection method based on the YOLOv11 architecture as claimed in claim 3, characterized in that: the feature aggregation calculation formula in step 3.3 is: Feature aggregation: Y agg =C*W agg +b agg (5) Where: W agg represents the convolution kernel, b agg Represents the bias vector.
5. The lightweight vehicle detection method for aerial images based on the YOLOv11 architecture according to claim 4, characterized in that: The calculation formula for output Y in step 3.5 is: Add attention and activation functions: Y final =σ(BN(CFAg(Y agg ))) (6) Where: σ(·) is the activation function; BN(·) is batch normalization, and CFAg(·) is channel attention aggregation.
6. The lightweight vehicle detection method for aerial images based on the YOLOv11 architecture according to claim 5, characterized in that: The specific implementation process of step 4 is as follows: enter Channel Compression: X1=σ(X*W1+b1) (7) Where: X1 represents the output feature of the layer, W1 represents the convolution kernel, and b1 represents the bias vector; Spatial downsampling (depthwise convolution):
7. The lightweight vehicle detection method for aerial images based on the YOLOv11 architecture according to claim 6, characterized in that: The specific implementation process of step 5.1 is as follows: 5×5 convolution kernel, padding=2; 9×9 convolution kernel, padding=4; Multi-scale pooling: P1=MaxPool(X,k=5,s=1,p=2) (9) P2=MaxPool(X,k=9,s=1,p=4) (10) Where: P represents the output feature map after pooling, MaxPool(.) represents the maximum pooling function, k represents the pooling kernel size, s represents the step size, and p represents padding.
8. A lightweight aerial image vehicle based on the YOLOv11 architecture as claimed in claim 7 The detection method is characterized by: The specific implementation process of step 5.2 is as follows: Splicing: C=Concat(X,P1,P2) (11) Fusion: Y=C*W fuse +b fuse (12)。 9. The lightweight vehicle detection method for aerial images based on the YOLOv11 architecture according to claim 8, characterized in that: The specific implementation process of step eight is as follows: The loss function inherits YOLOv11, including: L total =w1·L cls +w2·L DFL +w3·L IoU (14) Where: L total Represents the total loss function, w represents the weight coefficient, L cls represents the classification loss, L DFL represents the distribution focusing loss, L IoU represents the intersection-over-union loss.
10. The lightweight vehicle detection method for aerial images based on the YOLOv11 architecture according to claim 9, characterized in that: The specific processing flow of step nine is as follows: 9.1 Calculate the intersection-and-union ratio between prediction frames: Calculate the intersection-and-union ratio of all prediction frames pairwise, using At Measuring the degree of overlap; 9.2 Sort the prediction boxes by confidence: Sort the prediction boxes by confidence level from high to low. Low Sort by 9.3 Set the threshold and perform non-maximum suppression: Set the NMS threshold N. If the IoU of two predicted boxes is greater than the threshold, the one with higher confidence is retained and the one with lower confidence is suppressed. 9.4 Output the final detection results: retain the bounding box after NMS processing, and output the predicted category, bounding box coordinates and corresponding confidence score of each target.