© 2026 The authors. This article is published by IIETA and is licensed under the CC BY 4.0 license (http://creativecommons.org/licenses/by/4.0/).
OPEN ACCESS
Helmet detection for occupational and traffic safety requires lightweight models that operate continuously on resource-limited infrastructure. This study applied structured L1 channel pruning to YOLOv11n, targeting the inner bottleneck convolution pairs (cv1 and cv2) within C3K2 and C2f blocks while preserving outer projection dimensions. Two pruning ratios, 30% and 50%, were evaluated, followed by 20-epoch fine-tuning. Validation followed a 5-fold stratified cross-validation protocol on the Kaggle Helmet Detection dataset (764 images, 2 classes), with results reported as mean and standard deviation across folds. The baseline YOLOv11n achieved an mAP50 of 0.7889 ± 0.0331 at 203.49 ± 40.23 frames per second (FPS). The 30% pruned model reached an mAP50 of 0.7962 ± 0.0281, and the 50% pruned model reached 0.7882 ± 0.0366; neither change was statistically significant relative to the baseline (paired t-test, p = 0.42 and p = 0.95, respectively). At the 50% ratio, parameter count decreased by 8.20%, Open Neural Network Exchange (ONNX) model size by 8.00%, and Floating Point Operations (FLOPs) by 6.49%, while inference speed increased by 17.2% to 238.42 ± 11.09 FPS. Layer sensitivity analysis identified the early backbone convolution layers as most susceptible to channel removal, informing safer pruning targets. A pruning criteria comparison among L1, L2, and random selection showed comparable post-fine-tuning accuracy across criteria, with L1 producing the largest pre-fine-tuning drop (0.1115) and the fastest proxy inference speed. The pruned YOLOv11n outperformed YOLOv8n on identical hardware, achieving higher mAP50 (0.7882 versus 0.7733) with fewer parameters (2.378M versus 3.011M). This study presents the first application of structured L1 channel pruning to YOLOv11n for helmet detection and provides a reproducible compression baseline validated through statistical testing.
helmet detection, L1 channel pruning, YOLOv11n, model compression, cross-validation, structured pruning, edge deployment, object detection
Motorcycle accidents contribute to a significant proportion of global road deaths. The World Health Organization (WHO) reports that motorcycle riders and passengers face a disproportionately high risk of fatal injury [1]. Standard helmets reduce the risk of head injury by up to 70% [2]. Enforcing helmet regulations therefore remains a priority for the Indonesian government and for other countries facing similar road safety challenges.
Traditional methods relies on field officers, whose limited number is disproportionate to the volume of vehicles on the road. Manual supervision is error-prone, inconsistent, and cannot operate continuously [3]. This enforcement gap reduces the practical likelihood of detection, which in turn weakens compliance incentives for riders.
Computer vision offers an automated alternative to manual enforcement. Surveillance systems based on closed-circuit television (CCTV) cameras can identify helmetless riders in real time. Object detection models such as You Only Look Once (YOLO) have proven effective for this task [4, 5]. However, deployment on resource-constrained infrastructure remains challenging, since standard YOLO variants carry substantial computational overhead that limits scalability on servers processing multiple concurrent video streams.
YOLOv11n, the smallest variant of the YOLOv11 family, is designed for efficient deployment. Its multi-path efficient block architecture and loss-aware head design improve the accuracy-speed trade-off relative to earlier YOLO generations [6]. This model is well suited to continuous monitoring scenarios, although further optimization is required to maximize throughput under constrained compute budgets. Neural network pruning effectively reduces model complexity without substantial accuracy loss [7, 8], making it a natural candidate for this optimization.
A manual screening of 163 papers published between 2022 and 2024 indicates that YOLOv5 and YOLOv8 dominate helmet detection research, with various compression techniques applied to these architectures [9-11]. Existing pruning methods applied to these older YOLO variants report accuracy drops of 0.6-7% at compression ratios of 30-50% [12]. YOLOv11n, released in late 2024, has not yet been explored for the helmet detection task. Furthermore, automated structural pruning tools such as torch_pruning encounter compatibility issues with the C3K2 and C2PSA modules in YOLOv11n, particularly at the Concat operations within the Feature Pyramid Network and Path Aggregation Network. A focused inner bottleneck pruning strategy, which modifies only the cv1 and cv2 channel pairs inside each Bottleneck block while preserving the outer projection dimensions, avoids these dimensional conflicts and enables stable structured compression of this architecture.
This research makes four contributions. First, it presents the first implementation of structured L1 channel pruning on YOLOv11n for helmet detection, establishing a reproducible compression baseline for this architecture. Second, it validates the results through 5-fold stratified cross-validation with paired t-test and Wilcoxon signed-rank testing, providing statistical confirmation that pruning does not significantly degrade mAP50 at either ratio. Third, it provides a layer sensitivity analysis that identifies which backbone layers are most susceptible to channel removal, together with a pruning criteria comparison across L1, L2, and random selection. Fourth, it includes a direct comparison with YOLOv8n trained on identical hardware and dataset, demonstrating that the pruned YOLOv11n achieves higher accuracy with fewer parameters.
The remainder of this paper is organized as follows. Section 2 reviews related work on YOLO variants, helmet detection systems, and neural network pruning techniques. Section 3 describes the methodology, including the dataset, model architecture, pruning algorithm, cross-validation protocol, and experimental setup. Section 4 presents the results with complete metrics. Section 5 discusses the findings and compares them with the state of the art. Section 6 concludes the paper and outlines directions for future work.
2.1 You Only Look Once variants for object detection
The YOLO family has undergone significant evolution since its introduction. YOLOv1 started the one-stage detection paradigm with direct prediction of bounding boxes and class probabilities [13]. Anchor-based mechanisms in YOLOv3 improved the accuracy of small object detection [14]. YOLOv4 added the CSPDarknet53 backbone together with various augmentation techniques [15]. The next generation of YOLO models focused on efficiency. YOLOv5 introduced nano to extra-large variants for different computational budgets [16]. YOLOv7 used efficient layer aggregation networks [17]. YOLOv8 introduced anchor-free detection with a decoupled head design [6].
YOLOv11 includes C2PSA modules and C3K2 blocks for more efficient multi-scale feature capture [6]. Lightweight variants have emerged for edge deployment. YOLOv5-nano achieves a 1.9 MB model size with 45% mAP on COCO [18]. YOLOv8-nano improves performance to 37.3% mAP with a 3.2 MB size [19]. YOLOv11n continues this trend, targeting devices with limited RAM and processing power.
2.2 Helmet detection systems
Helmet detection has been explored using various YOLO versions. YOLOv5-SN achieves 31 frames per second (FPS) on the Jetson Nano using a ShuffleNetV2 backbone with 90% parameter reduction [20]. SG-YOLOv5 maintains baseline mAP while achieving a 90.8% parameter reduction and a 2.7x FPS improvement [21]. YOLOv8 variants have also been applied to this task. The AI City Challenge Track 5 uses YOLOv8 for multi-class helmet violation detection [22], and YOLOv8-ADown-LSCD achieves 0.85 mAP@0.5 on a custom dataset [23]. The Kaggle Helmet Detection dataset, containing 764 images, is frequently used as a research benchmark [24]. Dataset differences limit direct comparison across these studies, and generalization across varying camera conditions remains an open challenge.
2.3 Neural network pruning techniques
Structured pruning removes entire channels or filters, producing hardware-friendly sparse models without requiring specialized sparse computation libraries. Filter pruning with an L1-norm criterion has proven effective for practical deployment [25]. Li et al. [7] introduced a magnitude-based approach in which filters with small L1-norm weights are removed.
Batch normalization scaling factors serve as channel importance indicators. Network Slimming adds an L1 penalty to batch normalization (BN) gamma parameters during training [26]. NS-YOLO uses BN-based pruning in YOLOv5, achieving an 88.19% parameter reduction with only a 1.6% mAP drop [12]. A-pruning uses adaptive BN evaluation to select optimal subnetworks, achieving a 75.8% parameter reduction with a 0.9% accuracy drop on YOLOv5 [27]. Target Capacity Pruning designs compression to meet specific inference time constraints; on YOLOv5, a 30% pruning ratio loses 0.6% mAP, and a 50% ratio loses 2.9% [28]. SAFP-YOLO uses spatial attention-based filter pruning on YOLOv7, achieving substantial inference speed gains on embedded hardware [29].
CM-YOLOv8 applies L1-norm channel pruning for coal mine detection, achieving a 40% model volume reduction with less than 1% accuracy drop [30]. YOLOv8-ALWP uses layer-adaptive magnitude-based pruning, achieving a 64.67% parameter reduction together with a 1.7% accuracy improvement [31]. Compression techniques beyond pruning include knowledge distillation [32], quantization [33], and hybrid approaches that combine multiple compression strategies for deployment on platforms such as the Jetson Xavier NX [34].
2.4 Research gap and positioning
Existing work concentrates on YOLOv5, YOLOv7, and YOLOv8 variants. YOLOv11n, despite its architectural advantages, has not been studied for helmet detection, and no prior work applies structured pruning to this architecture. The C3K2 and C2PSA modules introduced in YOLOv11 create dimensional constraints at Concat junctions that prevent the direct application of existing global pruning pipelines. This gap motivates a targeted inner bottleneck pruning strategy that operates within each Bottleneck block, preserving outer channel dimensions while reducing internal redundancy. The present work addresses this gap by providing the first structured L1 channel pruning study on YOLOv11n, validated through cross-validation and statistical testing, and benchmarked against YOLOv8n under identical experimental conditions.
3.1 Dataset
The Helmet Detection dataset from Kaggle was used [24]. The collection contains 764 images with PASCAL VOC format annotations. Two classes are defined: with_helmet and without_helmet, with bounding box coordinates provided for each object. Figure 1 shows sample images from both classes. The dataset was split according to a standard ratio, with 70% (535 images) allocated to training, 15% (115 images) to validation, and 15% (114 images) to testing. A random shuffle was performed before splitting to ensure an even distribution across subsets.
This dataset presents several detection challenges. Helmets are small, typically occupying 5-10% of the image area. Rider pose variation is high, and occlusion from hands, visors, or passengers is common. Lighting conditions vary from bright daylight to backlit scenes, and a slight class imbalance exists, with marginally more with_helmet samples than without_helmet samples.
(a) With_helmet
(b) Without_helmet
Figure 1. Sample images from the Helmet Detection dataset: (a) with_helmet, (b) without_helmet
3.2 YOLOv11n architecture
YOLOv11n consists of three main components: a backbone that extracts features through convolutional layers, a neck that aggregates multi-scale information, and a head that produces the final predictions. Figure 2 shows the complete architecture.
Figure 2. YOLOv11n architecture overview
The backbone employs C3K2 modules that capture local and semi-global patterns using a two-kernel Bottleneck design [6]. The neck combines a Spatial Pyramid Pooling Fast (SPPF) [35] module at high-level layers with C2PSA modules that incorporate cross-stage partial connections and partial self-attention [6]. The detection head uses a decoupled, anchor-free design that separates classification and localization tasks. YOLOv11n contains 2,590,230 parameters in total, with Floating Point Operations (FLOPs) of approximately 6.38 G for a single 640 × 640 image.
3.3 Structured L1 channel pruning
Pruning targets the inner bottleneck convolution pairs, cv1 and cv2, within each Bottleneck block in the C3K2 and C2f modules of the backbone and neck. This layer scope was chosen to preserve the outer projection dimensions at block boundaries, avoiding dimensional conflicts at Concat operations in the Feature Pyramid Network and Path Aggregation Network. The detection head layers are excluded to maintain output structure.
Channel importance is determined by the L1 norm of the corresponding convolutional weights. For channel k in a cv1 layer with weight tensor W, the importance score is given by:
$I_k=\sum_{i=1}^N|W(k, i)|$ (1)
where $I_k$ is the importance score for channel k, W(k,i) is the filter weight at output channel k and weight index i, and N is the total number of weights per channel. Channels are sorted in ascending order by importance score, and the bottom r fraction is selected for removal:
$r=\frac{K_{\text {pruned }}}{K_{\text {total }}}$ (2)
Two ratios were tested: r = 0.30 and r = 0.50, with the pruning set defined as the channels with the lowest importance scores.
Algorithm 1 summarizes the inner bottleneck pruning procedure, including the cv1-cv2 consistency requirement that maintains valid tensor dimensions after channel removal.
|
Algorithm 1. Structured L1 Channel Pruning Algorithm |
|
Input: Pre-trained model M, pruning ratio r ∈ {0.30, 0.50} Output: Pruned and fine-tuned model M' 1: Load M from unfused checkpoint (bypass auto-fuse to expose Bottleneck weights) 2: Identify all Bottleneck blocks B = {b1, b2, ..., bn} in backbone and neck of M 3: For each block bi ∈ B: 4: For each channel k in bi.cv1.out_channels: 5: Compute Ik = Σ |W_cv1(k,:)| ▷ L1-norm over all weights of channel k 6: Sort channels ascending by Ik 7: Select $\underset{k}{\operatorname{argmin}} I_k$ such that $|P|=\left\lfloor r \times K_{\text {total }}\right\rfloor$ 8: Remove channels P from bi.cv1.out_channels 9: Remove corresponding input channels from bi.cv2.in_channels ▷ cv1-cv2 consistency 10: Fine-tune M' for 20 epochs (lr = 0.001, SGD, batch = 16, imgsz = 640) 11: Return M' |
3.4 Fine-tuning strategy
After pruning, the model is fine-tuned for 20 epochs to recover any accuracy lost from channel removal. The 20-epoch budget was determined by monitoring validation mAP curves during preliminary runs, which showed convergence consistently occurring within 15 epochs with no further improvement beyond that point. The fine-tuning learning rate is set to 0.001, one order of magnitude below the baseline initial rate of 0.01. This reduced rate prevents large gradient updates from disrupting the weight distributions of the remaining channels, which are already near their optimal configuration. The same SGD optimizer, momentum (0.937), weight decay (0.0005), batch size (16), and image resolution (640 × 640) used during baseline training are retained during fine-tuning to maintain consistency and avoid confounding factors. The best checkpoint based on validation mAP is saved at each epoch, and the final evaluation uses this checkpoint rather than the checkpoint from the last epoch.
3.5 5-fold cross-validation protocol
To ensure statistical robustness and reduce dependence on a single train-test split, all experiments adopt a 5-fold stratified cross-validation protocol. The dataset of 764 images is partitioned into five folds, maintaining the class distribution within each fold. For each fold, the remaining four folds form the training and validation pool, split 70%/15%, while the held-out fold serves as the test set. This procedure is repeated five times, with each fold serving as the test set exactly once. All three model configurations, baseline, pruned_30, and pruned_50, are trained and evaluated independently within each fold, ensuring that no test data influences training or pruning decisions.
Performance metrics are reported as the mean plus or minus one standard deviation across the five folds. Statistical comparison between the baseline and pruned models uses a paired t-test (n = 5) that treats each fold as a matched pair, supplemented by the Wilcoxon signed-rank test as a non-parametric confirmation. A significance threshold of alpha = 0.05 is applied. This dual-test approach was adopted because the small sample size (n = 5) limits the power of the t-test, and the Wilcoxon test provides additional assurance under non-normality.
3.6 Evaluation metrics
Mean Average Precision (mAP) measures detection accuracy. The metric averages precision across recall levels for each class, then averages the result across all classes:
$m A P=\frac{1}{C} \sum_{i=1}^C A P_i$ (3)
where, C is the number of classes (2 for this dataset) and APi is Average Precision for class i. Precision and recall are calculated from the confusion matrix:
$P=\frac{T P}{T P+F P}$ (4)
$R=\frac{T P}{T P+F N}$ (5)
This study reports mAP@0.5 (IoU threshold of 0.5) and mAP@0.5:0.95 (thresholds from 0.5 to 0.95 in steps of 0.05). The intersection over union (IoU) between the predicted bounding box (Bp) and the ground truth bounding box (Bgt) is calculated as:
$I o U=\frac{\left|B_p \cap B_{g t}\right|}{\left|B_p \cup B_{g t}\right|}$ (6)
Detections with IoU ≥ 0.5 are considered correct for mAP@0.5, while mAP@0.5:0.95 applies the stricter range of thresholds described above.
FPS measures inference throughput, with higher values indicating faster processing.
$F P S=\frac{1000}{t_{inference}}$ (7)
where, $t_{inference}$ is the inference time in milliseconds per image. Preprocessing and postprocessing time are excluded to isolate the computational cost of the model itself. Additional metrics include parameter count, Open Neural Network Exchange (ONNX) model file size (MB), and FLOPs.
ONNX format is used for model size measurement rather than the native PyTorch .pt checkpoint. The .pt format stores optimizer state, learning rate schedules, and training metadata in addition to the model weights, resulting in a file size that does not reflect the deployable model size. ONNX export strips all training artifacts, retaining only the inference graph and weights, and therefore provides a more accurate measure of deployment footprint.
3.7 Experimental setup
Experiments were conducted on two NVIDIA T4 GPUs in a Kaggle environment, using Python 3.11.13, PyTorch 2.6.0+cu124, and ultralytics 8.4.48. Baseline training ran for 100 epochs with an initial learning rate of 0.01 under a cosine annealing schedule. The SGD optimizer used a momentum of 0.937 and a weight decay of 0.0005. Image augmentations included random horizontal flip (50% probability), mosaic (probability 1.0), and mixup (probability 0.1). Input resolution was fixed at 640 × 640 pixels with a batch size of 16.
Automated structural pruning libraries such as torch_pruning, which builds dependency graphs via DepGraph [36], were evaluated but proved incompatible with the C3K2 and C2PSA modules of YOLOv11n: the Concat operations within the Feature Pyramid Network and Path Aggregation Network caused ignored-layer status to propagate across the dependency graph, preventing any channel removal. Pruning was therefore implemented through the custom procedure described in Algorithm 1, which directly modifies the cv1 and cv2 weight tensors of each Bottleneck block without relying on automated dependency resolution. Channel removal modifies the network architecture in place. Fine-tuning follows the configuration described in Section 3.4. Evaluation uses single-scale inference with a confidence threshold of 0.25 and an IoU threshold of 0.45 for non-maximum suppression. Figure 3 illustrates the complete workflow.
Table 1 summarizes hyperparameters that used in this research.
Figure 3. Complete experimental pipeline including 5-fold cross-validation, layer sensitivity analysis, pruning criteria ablation, structured L1 pruning, and statistical significance testing
Table 1. Training configuration
|
Parameter |
Baseline Training |
Fine-Tuning |
|
Base Model |
YOLOv11n |
YOLOv11n (pruned) |
|
Epochs |
100 |
20 |
|
Batch Size |
16 |
16 |
|
Image Size |
640 × 640 |
640 × 640 |
|
Initial LR |
0.01 |
0.001 |
|
Optimizer |
SGD (momentum 0.937) |
SGD (momentum 0.937) |
|
Weight Decay |
0.0005 |
0.0005 |
|
GPU |
NVIDIA T4 × 2 (Kaggle) |
NVIDIA T4 × 2 (Kaggle) |
|
Framework |
ultralytics 8.4.48 |
ultralytics 8.4.48 |
4.1 Overall performance
Table 2 reports the 5-fold cross-validation results for all three model configurations, together with YOLOv8n evaluated on identical hardware and dataset as a same-hardware baseline. All metrics are reported as the mean plus or minus one standard deviation across five folds, except for YOLOv8n, which was evaluated on the original single split for direct comparison.
Figure 4. Mean mAP50 with standard deviation across five folds for baseline, pruned_30, and pruned_50
Figure 5. Mean frames per second (FPS) with standard deviation across five folds
Figure 6. Mean Floating Point Operations (FLOPs) with standard deviation across five folds
Figure 7. Mean Open Neural Network Exchange (ONNX) model size with standard deviation across five folds
Table 2. Five-fold cross-validation results for baseline and pruned YOLOv11n configurations, with same-hardware YOLOv8n comparison
|
Model |
mAP50 |
mAP50-95 |
Precision |
Recall |
FPS |
Params (M) |
ONNX (MB) |
FLOPs (G) |
|
Baseline |
0.7889 ± 0.0331 |
0.4709 ± 0.0079 |
0.7788 |
0.7267 |
203.49 ± 40.23 |
2.590 |
10.11 |
6.38 |
|
Pruned 30% |
0.7962 ± 0.0281 |
0.4746 ± 0.0123 |
0.7579 |
0.7688 |
218.17 ± 46.27 |
2.462 |
9.63 |
6.12 |
|
Pruned 50% |
0.7882 ± 0.0366 |
0.4669 ± 0.0086 |
0.7559 |
0.7502 |
238.42 ± 11.09 |
2.378 |
9.30 |
5.97 |
|
YOLOv8n† |
0.7733 |
0.4672 |
0.7832 |
0.6791 |
211.67 |
3.011 |
11.70 |
8.14 |
mAP50 remained stable across both pruning ratios. The 30% pruned model produced a slightly higher mAP50 than the baseline (0.7962 versus 0.7889, a delta of +0.0073), which reflects a regularization effect from fine-tuning rather than a genuine accuracy gain. The 50% pruned model was nearly identical to the baseline (0.7882, a delta of -0.0006). Both differences are small in absolute terms and are discussed further in Section 4.6. FPS increased from 203.49 ± 40.23 for the baseline to 218.17 ± 46.27 for pruned_30 (+7.2%) and to 238.42 ± 11.09 for pruned_50 (+17.2%). The narrower FPS standard deviation for pruned_50 (11.09, compared with 40.23 for the baseline) suggests more consistent throughput after aggressive pruning. Figures 4 through 7 show the corresponding per-metric bar charts with error bars across folds.
4.2 Model compression analysis
Table 3 reports compression statistics relative to the baseline, using ONNX export size as the deployment-relevant measure.
Table 3. Compression statistics relative to baseline, based on ONNX export size
|
Model |
Params Reduction (%) |
FLOPs Reduction (%) |
ONNX Reduction (%) |
Compression Ratio |
Baseline ONNX (MB) |
Pruned ONNX (MB) |
|
Pruned 30% |
4.95% |
4.00% |
4.83% |
1.052x |
10.11 |
9.63 |
|
Pruned 50% |
8.20% |
6.49% |
8.00% |
1.089x |
10.11 |
9.30 |
The modest compression ratios, 1.052× and 1.089×, reflect the inner bottleneck scope of pruning. Only the cv1-cv2 channel pairs inside each Bottleneck block are modified, while the outer projection channels and all non-Bottleneck layers remain unchanged. This conservative scope is intentional: it avoids dimensional conflicts at Concat operations in the Feature Pyramid Network-Path Aggregation Network (FPN-PAN) structure and maintains architectural stability. As a consequence, the parameter and size reductions are smaller than those reported by methods that prune global channels or entire layers. The FLOPs reduction, 4.00% and 6.49%, follows a similar pattern, since the remaining backbone and neck layers continue to compute at full channel width.
4.3 Layer sensitivity analysis
Layer sensitivity was measured by temporarily masking 30% of channels in each eligible layer independently and recording the resulting proxy mAP50 drop without fine-tuning. Figure 8 shows the top 20 most sensitive layers. Table 4 lists the five layers with the highest sensitivity.
Figure 8. Top 20 layer sensitivity scores, where a larger drop indicates higher sensitivity to 30% channel masking
Table 4. Top-5 most sensitive layers to 30% channel masking (no fine-tuning)
|
Rank |
Layer Name |
Layer Index |
Out Channels |
mAP50 Drop |
Proxy mAP50 |
|
1 |
model.4.cv1.conv |
7 |
64 |
0.8034 |
0.0176 |
|
2 |
model.3.conv |
6 |
64 |
0.7180 |
0.1030 |
|
3 |
model.2.cv1.conv |
2 |
32 |
0.5059 |
0.3150 |
|
4 |
model.4.m.0.cv2.conv |
10 |
32 |
0.4320 |
0.3890 |
|
5 |
model.2.cv2.conv |
3 |
64 |
0.4142 |
0.4068 |
The five most sensitive layers are concentrated in the early backbone stages, specifically layer indices 2 through 10. Masking 30% of channels in model.4.cv1.conv (layer index 7) reduced proxy mAP50 from 0.8210 to 0.0176, a drop of 0.8034, making it the most critical layer by a substantial margin. model.3.conv (layer 6) and model.2.cv1.conv (layer 2) followed, with drops of 0.7180 and 0.5059, respectively. These early layers encode low-level texture and edge features that are fundamental to the subsequent feature pyramid. Their high sensitivity confirms that the inner bottleneck pruning strategy, which distributes channel removal across all Bottleneck blocks rather than concentrating it in any single sensitive layer, is an appropriate design choice for preserving post-pruning recoverability.
4.4 Pruning criteria comparison
To evaluate the choice of the L1 norm as the pruning criterion, a proxy ablation compared L1, L2, and random channel selection at a ratio of 0.30, without fine-tuning. All three criteria produced the same parameter count and FLOPs, since the number of removed channels was identical and only the selection policy differed. Table 5 and Figure 9 report the resulting proxy mAP50 drops.
Table 5. Pruning criteria comparison at ratio = 0.30, proxy evaluation without fine-tuning
|
Criterion |
mAP50 (Before FT) |
mAP50 Drop |
FPS (no FT) |
Params |
FLOPs (G) |
|
L2 |
0.7316 |
0.0893 |
241.63 |
2,462,106 |
6.12 |
|
Random |
0.7105 |
0.1105 |
244.32 |
2,462,106 |
6.12 |
|
L1 (ours) |
0.7095 |
0.1115 |
277.00 |
2,462,106 |
6.12 |
Figure 9. Proxy mAP50 drop before fine-tuning for L1, L2, and random pruning criteria at 30% ratio
The proxy evaluation showed that L1 produced the largest pre-fine-tuning mAP50 drop (0.1115), followed by Random (0.1105) and L2 (0.0893). The L1 criterion selects the channels with the smallest absolute weight magnitudes, which are the channels that the network currently uses least. After fine-tuning, all three criteria converged to similar final accuracy, with a delta from baseline of less than 0.01 in each case, consistent with the interpretation that magnitude-based pruning produces models that are more amenable to recovery, since the removed channels were already contributing little to the representation. L1 was selected over L2 for two reasons: its proxy inference speed was the highest among the three criteria (277.00 FPS, versus 241.63 for L2 and 244.32 for Random), and it is computationally simpler to calculate. The post-fine-tuning accuracy difference across criteria was negligible.
4.5 Precision-recall curve and F1-score analysis
Precision-recall curves and F1-score curves are reported for fold 0 across all three model configurations, which is representative of the cross-validation distribution. Figures 10 through 15 show the PR and F1 curves for the baseline, pruned_30, and pruned_50 models.
Figure 10. Precision-recall curve, baseline model (fold 0)
Figure 11. Precision-recall curve, pruned_30 model (fold 0)
Figure 12. Precision-recall curve, pruned_50 model (fold 0)
Figure 13. F1-score curve, baseline model (fold 0)
Figure 14. F1-score curve, pruned_30 model (fold 0)
Figure 15. F1-score curve, pruned_50 model (fold 0)
The precision-recall curves show that the pruned models maintained an area under the curve close to that of the baseline. The curve shapes were consistent across the three configurations, with no visible collapse in the high-recall region. Precision at recall = 1.0 was slightly lower for the pruned models, indicating a marginal increase in false positives at the extreme of the recall range. The F1-score curves confirmed that the optimal confidence threshold shifted only slightly after pruning, and the peak F1 value remained comparable across configurations. For helmet detection, where missing a violation is more costly than generating a false alarm, this slight precision-recall trade-off introduced by pruning is acceptable.
4.6 Statistical significance
Table 6 reports the results of the paired t-test and Wilcoxon signed-rank test for mAP50 and FPS comparisons between the baseline and each pruned model, using the 5 folds results as matched pairs.
Table 6. Statistical significance tests for mAP50 and frames per second (FPS) (n = 5 folds, alpha = 0.05)
|
Comparison |
Metric |
Mean Baseline |
Mean Pruned |
Delta |
P (t-Test) |
P (Wilcoxon) |
Significant |
|
Baseline vs Pruned 30% |
mAP50 |
0.7889 |
0.7962 |
+0.0073 |
0.4222 |
0.8125 |
No |
|
Baseline vs Pruned 30% |
FPS |
203.49 |
218.17 |
+14.68 |
0.5333 |
0.6250 |
No |
|
Baseline vs Pruned 50% |
mAP50 |
0.7889 |
0.7882 |
-0.0006 |
0.9540 |
0.8125 |
No |
|
Baseline vs Pruned 50% |
FPS |
203.49 |
238.42 |
+34.93 |
0.1018 |
0.1250 |
No |
No comparison reached statistical significance at alpha = 0.05. For mAP50, p = 0.42 for pruned_30 and p = 0.95 for pruned_50, confirming that pruning did not significantly degrade accuracy at either ratio. The FPS differences were also not statistically significant (p = 0.53 for pruned_30 and p = 0.10 for pruned_50). This indicates that the observed throughput increases should be interpreted with caution given the variance across folds; the n = 5 sample size limits statistical power, and the p = 0.10 result for pruned_50 is a borderline finding that warrants evaluation on additional data. The absence of significance for mAP50 is the primary result of interest, as it provides statistical evidence that the pruned models performed equivalently to the baseline on this dataset.
4.7 Comparison with YOLOv8n on identical hardware
To provide a fair same-hardware baseline, YOLOv8n was trained and evaluated on the same dataset and hardware configuration, NVIDIA T4, used for the revision experiments. Table 7 compares YOLOv8n against the three YOLOv11n configurations.
The pruned_50 YOLOv11n achieved an mAP50 of 0.7882, exceeding YOLOv8n at 0.7733, while using 21% fewer parameters (2.378M versus 3.011M), 20.5% less ONNX storage (9.30 MB versus 11.70 MB), and 26.6% fewer FLOPs (5.97 G versus 8.14 G). FPS for pruned_50 (238.42) also exceeded YOLOv8n (211.67). This comparison establishes that pruning YOLOv11n produces a model that is simultaneously more accurate, faster, and smaller than the previous-generation architecture trained under equivalent conditions.
Table 7. Direct comparison of YOLOv11n configurations with YOLOv8n on NVIDIA T4 hardware and identical dataset
|
Model |
mAP50 |
FPS |
Params (M) |
ONNX (MB) |
FLOPs (G) |
Hardware |
|
YOLOv11n Baseline |
0.7889 |
203.49 |
2.590 |
10.11 |
6.38 |
NVIDIA T4 |
|
YOLOv11n Pruned 30% |
0.7962 |
218.17 |
2.462 |
9.63 |
6.12 |
NVIDIA T4 |
|
YOLOv11n Pruned 50% |
0.7882 |
238.42 |
2.378 |
9.30 |
5.97 |
NVIDIA T4 |
|
YOLOv8n |
0.7733 |
211.67 |
3.011 |
11.70 |
8.14 |
NVIDIA T4 |
4.8 Detection quality analysis
The confusion matrices for fold 0 across the three configurations are shown in Figures 16 through 18. The pattern across configurations is consistent with the quantitative mAP50 results reported in Table 2. The baseline model correctly classified the majority of with_helmet and without_helmet instances, with a small proportion of false negatives concentrated in occluded or small-scale instances. The pruned_30 model showed a comparable classification pattern, with no systematic shift in the false positive or false negative distribution relative to the baseline. The pruned_50 model similarly maintained a confusion structure close to the baseline, consistent with the statistically negligible mAP50 delta of -0.0006 (p = 0.95) reported in Table 6. These observations confirm that channel removal at either ratio did not introduce a systematic bias toward either class.
Figure 16. Confusion matrix model baseline (fold 0)
Figure 17. Confusion matrix model pruned 30% (fold 0)
Figure 18. Confusion matrix model pruned 50% (fold 0)
Figure 19. Detection results sample for baseline (fold 0)