Resource-Efficient Helmet Detection Using Structured L1 Channel Pruning of YOLOv11n

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.

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.

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 AP_i 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 (B_p) and the ground truth bounding box (B_gt) 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

The 5-fold cross-validation results confirmed that structured L1 channel pruning on the inner bottleneck pairs of YOLOv11n does not significantly degrade mAP50 at either the 30% or 50% pruning ratio. The mAP50 delta of -0.0006 for pruned_50 (p = 0.95) represents statistical equivalence with the baseline. The slight mAP50 increase for pruned_30 (+0.0073, p = 0.42) is consistent with a mild regularization effect from fine-tuning: removing lower-magnitude channels reduces overfitting to the training distribution, and the subsequent 20-epoch fine-tuning on the remaining capacity allows the model to converge to a slightly more generalizable solution. Neither result represents a genuine architectural improvement; both fall within the normal variance range observed across folds.

The compression ratios achieved, 1.052x and 1.089x, are modest compared with methods that apply global channel pruning or remove entire layers. This outcome is a direct consequence of the inner bottleneck scope, which was selected specifically to avoid dimensional conflicts at Concat operations in the FPN-PAN structure. Methods such as NS-YOLO (88% parameter reduction) and A-pruning (76% reduction) operate on YOLOv5, which has a simpler skip-connection topology that accommodates more aggressive global pruning [12, 27]. For YOLOv11n, the C3K2 and C2PSA modules with their multi-path cross-stage connections impose stricter constraints. The inner bottleneck approach trades compression depth for architectural safety and recoverability, a trade-off that the 5-fold results confirm is sound for this architecture.

The pruning criteria comparison provides insight into why L1 was selected. The proxy mAP50 drop for L1 (0.1115) exceeded those of Random (0.1105) and L2 (0.0893), indicating that L1 selected channels that, when removed, initially disrupted the representation more than the channels selected by L2. This result may appear counterintuitive, since L1 is a magnitude-based criterion that targets the smallest weights. The explanation is that L2 penalizes large deviations from zero more strongly, so the channels it selects tend to have intermediate magnitudes and may contribute more evenly distributed redundancy. L1 selects the absolute minimum contributors, which can include channels whose small magnitude results from learned suppression rather than genuine redundancy. After 20 epochs of fine-tuning, however, all three criteria converged to comparable final accuracy, confirming that the initial disruption is recoverable and that the choice of criterion matters primarily for the speed of convergence during fine-tuning. L1 was favored because its computational cost is lower, one absolute-value sum per channel versus a squared sum for L2, and its proxy inference speed was the highest among the three criteria (277.00 FPS, versus 241.63 for L2), suggesting that the channels it removes are concentrated in layers where their removal yields more consistent computational savings. Importance criteria that explicitly incorporate hardware energy consumption rather than weight magnitude alone have also been proposed [37] and represent a possible direction for further refining the channel selection policy used in this work.

The direct comparison with YOLOv8n under identical hardware and data conditions addresses a limitation common to SOTA comparisons that mix different hardware platforms. YOLOv11n pruned_50 outperformed YOLOv8n on all reported metrics, including mAP50, FPS, parameter count, ONNX size, and FLOPs. This result suggests that the architectural improvements introduced in YOLOv11, namely the C3K2 blocks and C2PSA attention modules, provide a richer feature representation that is maintained even after channel reduction, whereas YOLOv8n, despite having no pruning applied, achieved lower accuracy with more parameters. The implication is that YOLOv11n is a more efficient starting point for compression than its predecessor for this task.

Table 8. Comparison with state-of-the-art structured pruning methods. Negative drop indicates accuracy improvement after pruning

Table 8 positions the proposed method against published pruning results. Direct performance comparison across rows must be interpreted with caution, since the hardware platforms differ substantially, ranging from embedded Jetson and Android NCNN deployments to server-grade GPUs. The hardware column is included explicitly to allow readers to account for this confound. Relative accuracy retention and the pruning ratio are the most hardware-agnostic dimensions of comparison.

Against the methods that operate at comparable pruning ratios, the proposed approach achieved the smallest accuracy degradation. Target Capacity Pruning reported a 0.6% drop at a 30% ratio and a 2.9% drop at a 50% ratio on YOLOv5; the present work reported a 0.06 percentage-point drop at the 50% ratio, consistent with statistical equivalence to the baseline. The speed gains reported here, 7.2% and 17.2%, are more modest than those in most comparative entries, which reflects honest reporting under 5-fold cross-validation on a server-grade GPU rather than a single-run measurement. The larger gains reported by methods such as A-pruning (+170%) and SAFP-YOLO (+426%) were measured on Jetson platforms, where architectural compression interacts differently with hardware-specific inference optimizations; these results are not directly comparable to server GPU throughput. The primary contribution of the present work relative to the state of the art is accuracy retention under a formally validated experimental protocol, applied to an architecture, YOLOv11n, for which no prior pruning baseline exists.

From a practical deployment standpoint, the pruned models processed video at 218 to 238 FPS on a server-grade GPU, well above the 30 FPS threshold typically required for real-time single-stream processing. A server handling multiple simultaneous camera feeds can dedicate a portion of GPU time to each stream; at 238 FPS per model, approximately seven concurrent streams could be processed at 30 FPS on a single GPU instance. Fine-tuning the pruned model from a pre-trained checkpoint requires approximately 20 epochs, which at the dataset scale used here corresponds to a training time of roughly 20 to 30 minutes on an NVIDIA T4 GPU, making retraining for domain adaptation practical. Deployment conditions not evaluated in this study include adverse weather, such as rain, fog, or low light at night, extreme camera angles, and partial occlusion by non-helmet head coverings. These conditions are common in real traffic environments and represent open questions for deployment robustness.

Several limitations affect the scope of these conclusions. First, the dataset used, 764 images, is small for an object detection benchmark. Although 5-fold cross-validation provides more robust estimates than a single split, the absolute confidence intervals on mean performance remain wide, with a standard deviation of 0.033 for baseline mAP50. Evaluation on larger or more diverse datasets is necessary to establish generalization beyond this benchmark. Second, all speed measurements were conducted on an NVIDIA T4 server GPU. The observed FPS improvements, 7.2% for pruned_30 and 17.2% for pruned_50, may not translate proportionally to edge devices such as the Jetson Nano or Raspberry Pi, where memory bandwidth and SIMD instruction availability differ substantially. Evaluation on at least one embedded platform is required before any claims about edge deployment can be made. Third, pruning was restricted to inner bottleneck channels to avoid Concat dimension conflicts; outer channel pruning would require additional architectural handling, such as padding or channel adaptation at FPN merge points, and has not been attempted in this study.