LGA-YOLO: A Light Weight and High-Performance Network for Bubble Detection

Abstract

Precise bubble detection is fundamental to process control in chemical engineering and oceanography, yet deploying heavy deep learning models on edge devices is often impractical due to hardware constraints. To bridge this gap, we present LGA-YOLO, a streamlined evolution of YOLO11n optimized for high-speed industrial inspection. By synergizing ghost convolutions with channel shuffling and incorporating a novel Triplet Attention-based feature enhancement, our design systematically eliminates redundancy without compromising discriminative power. The architecture integrates four specialized components—LightShuffleGhostConv, C3k2Ghost, LSPPF, and LightC2fPSA—to maximize efficiency. On our custom side-illuminated bubble dataset, LGA-YOLO maintains a high mAP@50 of 89.0% and mAP@50–95 of 67.0%, with a precision of 90.1% and recall of 85.1%. Crucially, it slashes the parameter count by 67% and FLOPs by 56% compared to the baseline, establishing itself as a viable, high-performance solution for real-time embedded monitoring.

1. Introduction

The rapid evolution of convolutional neural networks (CNNs) has revolutionized general object detection [1,2], yet specific industrial tasks like bubble monitoring present stubborn challenges [3,4]. Unlike opaque objects in standard datasets, bubbles are transparent, overlap heavily, and deform rapidly—characteristics that confound standard detectors, especially under the complex lighting of chemical reactors or seabed seeps. Furthermore, industrial environments are notoriously harsh; background noise and low contrast at bubble boundaries often render conventional backlighting techniques ineffective for resolving dense clusters.

While state-of-the-art architectures, particularly the YOLO (You Only Look Once) series [5,6,7,8], have set new benchmarks for accuracy, their computational weight often disqualifies them from deployment on resource-constrained edge devices such as embedded sensors, drones, or mobile monitoring units. The recently released YOLO11 offers a robust baseline [9], yet its standard convolution blocks still carry significant redundancy that is unnecessary for specialized, high-contrast tasks.

To address these inefficiencies, we introduce SILB-DB, a dataset constructed using a novel side-illuminated imaging setup that explicitly enhances edge contrast. Leveraging this high-quality data, we engineered LGA-YOLO, a streamlined architecture that systematically strips away computational excess while sharpening focus on bubble features through efficient attention mechanisms.

The primary contributions of this work are summarized as follows:

1.

Dataset Innovation: We release SILB-DB, a specialized benchmark captured with side illumination to resolve bubble contours in complex flows, addressing the data scarcity in this domain.

2.

LGA-YOLO Architecture: We propose a novel lightweight detector that systematically integrates four specialized modules—LightShuffleGhostConv, C3k2Ghost, LSPPF, and LightC2fPSA. This synergistic design effectively eliminates redundancy through ghost convolutions and enhances feature representation via Triplet Attention, establishing a new accuracy–efficiency benchmark for industrial edge inspection.

The rest of this paper is organized as follows: Section 2 reviews related work in efficient neural networks and bubble detection. Section 3 details the methodology and experimental design. Section 4 presents the proposed architecture and experimental results. Finally, Section 5 discusses the implications, and Section 6 concludes this paper.

2. Related Work

This section reviews the technological foundations relevant to our work, focusing on efficient neural network designs, attention mechanisms, the evolution of the YOLO architecture, and specific advances in bubble detection. We also examine the role of spatial pyramid pooling in enhancing multi-scale feature representation.

2.1. Efficient Neural Network Design

Lightweight Architectures. The pursuit of efficient neural networks has led to numerous architectural innovations. MobileNet [10] introduced depthwise separable convolutions, reducing computational cost while maintaining accuracy. ShuffleNet [11] proposed channel shuffle operations to enable information flow between group convolutions, achieving better accuracy–efficiency trade-offs. More recently, EfficientNet [12] demonstrated that a careful balance of network depth, width, and resolution leads to superior performance. Furthermore, structural re-parameterization techniques like RepVGG [13] and MobileOne [14] decouple training and inference architectures to boost speed, while modern ConvNets such as ConvNeXt [15] modernize standard ResNet blocks for improved accuracy–latency trade-offs.

Ghost Convolutions. Han et al. [16] observed that feature maps in deep networks often contain redundant information, with many features being similar “ghosts” of each other. GhostNet exploits this redundancy by generating feature maps in two stages: first computing a small set of intrinsic features using standard convolutions and then applying cheap linear operations to generate additional “ghost” features. This approach reduces both parameters and FLOPs by approximately 50% while maintaining competitive accuracy.

2.2. Attention Mechanisms for Object Detection

Channel Attention. Squeeze-and-Excitation Networks (SENets) [17] pioneered channel attention by adaptively recalibrating channel-wise features through global pooling and fully connected layers. However, the dimensionality reduction introduces additional computational overhead. Wang et al. [18] proposed ECA-Net (Efficient Channel Attention), which replaces fully connected layers with 1D convolutions, achieving better efficiency with comparable or superior performance. The adaptive kernel size selection based on channel dimensions makes ECA particularly suitable for lightweight models.

Spatial and Cross-Dimensional Attention. CBAM [19] combines channel and spatial attention modules sequentially. Misra et al. [20] introduced Triplet Attention, which captures cross- dimensional interactions by computing attention across three branches: channel– height, channel–width, and height–width. Unlike CBAM, Triplet Attention uses Z-pooling (concatenating max and average pooling) and avoids expensive fully connected layers, making it more parameter-efficient.

Position-Sensitive Attention. The recently proposed PSA module in YOLO11 [9] employs multi-head self-attention with position- sensitive features. While effective, it introduces significant computational overhead ($\approx 7C^2$ parameters for dimension C), making it challenging for deployment on resource-constrained devices.

2.3. YOLO Series Evolution

YOLO Architecture Development. The YOLO family has evolved from YOLOv1’s single-stage detection [5] through numerous iterations. YOLOv5 [6] introduced CSPNet-based backbones for efficient feature extraction. YOLOX [8] adopted anchor-free detection with decoupled heads. YOLOv8 [7] improved the architecture with C2f modules and enhanced loss functions. Recent iterations like YOLOv9 [21] introduced Programmable Gradient Information (PGI) to mitigate information loss in deep networks, while YOLOv10 [22] proposed an NMS-free training strategy to further reduce inference latency.

YOLO11 Architecture. The latest YOLO11 [9] introduces several innovations: (1) C3k2 modules for efficient CSP structures, (2) SPPF for multi-scale feature aggregation, and (3) C2PSA modules incorporating position- sensitive attention. While achieving state-of-the-art accuracy, YOLO11’s parameter count (≈9 M) and computational cost (≈6.6 G FLOPs) remain substantial for edge deployment.

Lightweight YOLO Variants. Several works have explored lightweight YOLO designs. YOLOv5-Lite [23] applied depthwise convolutions and channel pruning. PP-YOLO-Tiny [24] was optimized for mobile devices using knowledge distillation. However, these methods often sacrifice considerable accuracy or fail to address all computational bottlenecks systematically.

2.4. Deep Learning for Bubble Detection

Traditional vs. Deep Learning Approaches. Traditional bubble detection methods often rely on watershed algorithms or Hough transforms, which struggle with overlapping bubbles and complex backgrounds. In recent years, deep learning has demonstrated superior performance. Ren et al. [1] and Liu et al. [2] established the foundation for two-stage and one-stage detectors, respectively, which have been adapted for particle detection.

Specific Applications. In industrial settings, deep learning has been applied to measure bubble size distributions in gas–liquid flows. For instance, Poślad et al. [3] utilized convolutional neural networks to segment dense bubble clusters in chemical reactors. In oceanography, Wang et al. [4] adapted object detection models to identify and track methane bubbles from seabed seeps. Furthermore, segmentation-based approaches using Mask R-CNN [25] and improved U-Net variants [26] have proven effective in extracting precise bubble masks in flotation froths, though often at higher computational costs. Despite these successes, most existing solutions prioritize detection accuracy over computational efficiency, often utilizing heavy backbones that are unsuitable for real-time edge processing in remote monitoring systems.

2.5. Spatial Pyramid Pooling

SPP and SPPF. Spatial pyramid pooling (SPP) [27] captures multi-scale contextual information by pooling features at different scales, allowing the network to process inputs of arbitrary sizes. This technique has been widely adapted for object detection. For instance, Huang et al. [28] proposed DC-SPP-YOLO, integrating dense connections with SPP to enhance feature extraction in YOLOv2. More recently, Liu et al. [29] incorporated the faster SPPF module into SF-YOLOv5 to improve small object detection efficiency. Zhang et al. [30] further evolved this concept with SPFFNet, combining strip perception with feature fusion to detect fabric defects. Jocher et al. [6] introduced SPPF (SPP-Fast) in YOLOv5, which achieves equivalent receptive fields through serial pooling operations, reducing computation while maintaining performance. However, the hidden dimension in SPPF (typically $C/2$ for input C) still contributes significantly to parameter count in deep stages.

3. Methodology and Experimental Design

This study adopts a constructive research approach, aiming to resolve the trade-off between detection accuracy and computational efficiency in industrial bubble monitoring. We hypothesize that the redundancy in modern detector backbones can be mathematically reduced using linear transformations (ghost convolutions) and that expensive self-attention can be substituted with cross-dimensional interaction (Triplet Attention) without significant information loss. The primary research questions guiding this work are as follows: (1) Can we systematically replace standard convolutions in YOLO11 to fit edge constraints? (2) Does a specialized side-illuminated dataset improve detection of transparent objects compared to standard lighting?

3.1. Experimental Setup

Imaging Platform and Dataset. As illustrated in Figure 1, we built an in-house high-speed imaging platform to acquire bubble imagery and construct the SILB-DB (Side-Illuminated Light Field Bubble Database). The imaging setup comprises three key components: (1) a high-speed camera set to a frame rate of 500 fps with an exposure time (shutter speed) of 1000 μs; (2) a lateral, directional LED illumination source positioned to explicitly enhance the contrast of bubble boundaries; and (3) a transparent observation channel. We collected 200 high-quality images at a resolution of $300\times 640$ pixels. The dataset is released under the Creative Commons Attribution 4.0 International (CC BY 4.0) license.

Figure 1. The in-house high-speed imaging platform for bubble data acquisition. The setup includes (1) directional LED illumination, (2) a high-speed camera, and (3) a transparent observation channel.

Data Annotation and Split. Using the professional annotation tool x-anylabelimg we manually labeled a total of 72,738 bubbles. Although the dataset consists of 200 source images, the high density of instances (over 360 bubbles per image on average) provides a rich feature set for training. To further mitigate the risk of overfitting and ensure statistical robustness, we employed (1) rigorous data augmentation (including Mosaic and Mixup) and (2) a 5-fold cross-validation scheme, as detailed in Section 4.2. The dataset was initially split into training and test sets at a 9:1 ratio for the baseline experiments.

Training Configuration. Training was conducted for 200 epochs using the Stochastic Gradient Descent (SGD) optimizer, initialized with a learning rate of 0.01 and a momentum of 0.937. To mitigate the risk of overfitting on the limited dataset, we employed standard data augmentation strategies, including Mosaic augmentation, random horizontal flips, and color jittering. The input image size was set to $640\times 640$. All experiments were performed on a single NVIDIA GeForce RTX 3090 GPU.

3.2. Performance Metrics

We evaluate the model using precision (P), recall (R), Mean Average Precision at IoU = 0.5 (mAP@50), and mAP@50–95. Computational efficiency is measured by parameter count (Params) and Floating-Point Operations (FLOPs).

4. Results

In this section, we present the architectural specification of the proposed LGA-YOLO model as the primary outcome of our design methodology, followed by a comprehensive empirical validation against state-of-the-art baselines.

4.1. Proposed LGA-YOLO Architecture

The proposed LGA-YOLO retains the macro-architecture of YOLO11 but systematically replaces computationally intensive modules with lightweight alternatives. Figure 2 presents the detailed architecture of the proposed model. The input image is first processed by the backbone, where C3k2Ghost blocks extract multi-scale features while reducing redundancy. Then, the neck network, utilizing LightShuffleGhostConv and LSPPF modules, fuses these features to capture contextual information. Finally, the head predicts bounding boxes and class probabilities. The network integrates four specialized components to maximize efficiency.

Figure 2. The overall architecture of LGA-YOLO. The model integrates LightShuffleGhostConv, C3k2Ghost, LSPPF, and LightC2fPSA modules to achieve lightweight yet high-performance bubble detection.

4.1.1. LightShuffleGhostConv Module

Standard convolutions incur high computational costs. Inspired by GhostNet [16], we introduce LightShuffleGhostConv. As shown in Figure 3, this module generates feature maps using a two-step process to mitigate redundancy.

Figure 3. Structure of the LightShuffleGhostConv module compared to standard convolution. The module splits feature generation into primary and ghost branches, followed by channel shuffling.

Given input features $X\in {\mathbb{R}}^{C_1\times H\times W}$, where $C_1$, H, and W denote the number of input channels, height, and width, respectively, a standard convolution producing $Y\in {\mathbb{R}}^{C_2\times H^{\prime }\times W^{\prime }}$ with kernel size k requires a computational cost (FLOPs) of

$$FLOP{s}_{std}=C_1·C_2·k·k·H^{\prime }·W^{\prime }$$

(1)

In our LightShuffleGhostConv, we first generate a primary part of the features $Y_{primary}\in {\mathbb{R}}^{{\displaystyle \frac{C_2}{2}}\times H^{\prime }\times W^{\prime }}$ using a standard convolution with fewer filters and then generate the remaining features $Y_{ghost}$ using a cheap depth-wise operation:

$$\begin{array}{cc}\hfill Y_{primary}& =Conv(X;W_1),W_1\in {\mathbb{R}}^{{\displaystyle \frac{C_2}{2}}\times C_1\times k\times k}\hfill \\ \hfill Y_{ghost}& =DWConv(Y_{primary};W_2),W_2\in {\mathbb{R}}^{{\displaystyle \frac{C_2}{2}}\times 1\times k\times k}\hfill \end{array}$$

(2)

The final output is obtained by concatenating and shuffling the channels to enable information flow:

$$Y=ChannelShuffle\left(Concat\left([Y_{primary},Y_{ghost}]\right)\right)$$

(3)

This design reduces the parameters by approximately 50% compared to standard convolutions:

$$R_p={\displaystyle \frac{P_{ghost}}{P_{std}}}\approx {\displaystyle \frac{\frac{1}{2}{C}_1{C}_2{k}^2+\frac{1}{2}{C}_2{k}^2}{C_1{C}_2{k}^2}}\approx {\displaystyle \frac{1}{2}}$$

(4)

4.1.2. C3k2Ghost Bottleneck

The C3k2 module in YOLO11 is a core component for feature extraction but imposes a substantial parameter burden. We propose C3k2Ghost, which integrates LightShuffleGhostBottleneck blocks, as illustrated in Figure 4.

Figure 4. Architecture of the C3k2Ghost module. The module employs ghost bottlenecks with a split–mix strategy for efficient feature extraction.

This block employs a split–transform–merge strategy where features are processed by depth-wise convolutions (for spatial information) and point-wise convolutions (for channel information) separately. This structure, known as LightSplitMix, significantly reduces the parameter count of the bottleneck layers by over 70% while preserving feature diversity. The mathematical formulation is defined as follows:

$$\begin{array}{cc}\hfill Y_{split}& =\mathrm{Conv}(X;W_{split},k=1),Y_{split}\in {\mathbb{R}}^{2C_{mid}\times H\times W}\hfill \\ \hfill Y_1,Y_2& =\mathrm{Split}\left(Y_{split}\right),\mathrm{each}\in {\mathbb{R}}^{C_{mid}\times H\times W}\hfill \\ \hfill Y_2^{\prime }& ={\mathrm{LSGBottleneck}}^n\left(Y_2\right)\hfill \\ \hfill Y_{out}& =\mathrm{Conv}(\mathrm{Concat}\left([Y_1,Y_2^{\prime }]\right),k=1)\hfill \end{array}$$

(5)

where n denotes the number of stacked bottleneck blocks.

4.1.3. LSPPF: Lightweight SPP with Attention

The Spatial Pyramid Pooling-Fast (SPPF) module typically uses a large number of hidden channels ($C_{hidden}=C_{in}/2$). We propose LSPPF, which reduces the hidden channel ratio to 0.25 ($C_{hidden}=C_{in}/4$) to save parameters. To compensate for the potential loss of information capacity, we integrate the Efficient Channel Attention (ECA) mechanism, as shown in Figure 5.

Figure 5. LSPPF module architecture with reduced hidden channels and integrated ECA attention for enhanced feature representation.

ECA utilizes a 1D convolution with an adaptive kernel size k to capture local cross-channel interactions:

$$\omega =\sigma \left(Conv1D_k\left(GAP\left(X\right)\right)\right)$$

(6)

where $GAP$ denotes Global Average Pooling and $\sigma$ is the Sigmoid function. This adds negligible parameters ($k\approx 5$) while boosting the representation power of the pooled features.

4.1.4. LightC2fPSA with Triplet Attention

The C2PSA module in YOLO11 uses standard multi-head self-attention (MHSA), which has quadratic complexity $O\left(N^2\right)$. We replace this with LightC2fPSA, incorporating Triplet Attention [20], as illustrated in Figure 6.

Figure 6. The LightC2fPSA module with the Triplet Attention mechanism. The attention operates across three complementary dimensions to capture spatial and channel dependencies efficiently.

The LightC2fPSA module integrates two key components: Triplet Attention for cross-dimensional feature interaction and a lightweight Feed-Forward Network (LightFFN) for channel transformation.

Triplet Attention. Triplet Attention captures cross-dimension interactions using three parallel branches:

$$Y={\displaystyle \frac{1}{3}}(Y_{CW}+Y_{HC}+Y_{HW})$$

(7)

where $Y_{CW}$, $Y_{HC}$, and $Y_{HW}$ represent the attention maps generated from channel–width, height–channel, and height–width dimensions, respectively. Each branch employs an AttentionGate that utilizes Z-pooling (concatenating max-pooled and average-pooled features) followed by a $7\times 7$ convolution to generate attention weights with minimal parameters ($k=7,C_{in}=2$).

LightFFN. To further reduce redundancy, we replace the standard FFN with LightFFN. Unlike standard FFNs that expand channels by a factor of 2, LightFFN first reduces channels by half, applies a depth-wise convolution for spatial context, and then expands back to the original dimension. This “bottleneck” structure reduces FFN parameters by approximately 75%.

Overall, this design eliminates heavy matrix multiplications and reduces the computational cost of the attention block by approximately 84%.

4.2. Quantitative Analysis

Table 1 presents a comprehensive comparison between the baseline YOLO11n and our proposed LGA-YOLO model.

Table 1. Performance comparison between YOLO11n and LGA-YOLO on the bubble dataset.

Model	Params (M)	FLOPs (G)	P	R	mAP@50	mAP@50–95
YOLO11n	9.00	6.60	0.904	0.860	0.893	0.672
LGA-YOLO	2.93	2.90	0.901	0.851	0.890	0.670
Reduction	67.4%	56.0%	−0.3%	−1.0%	−0.3%	−0.3%

As shown in Table 1, LGA-YOLO achieves remarkable efficiency improvements with minimal accuracy loss. The model reduces parameters by 67.4% (from 9.00 M to 2.93 M) and computational cost by 56.0% (from 6.6 G to 2.9 G FLOPs), while maintaining competitive detection performance with only a 0.3% decrease in mAP@50. To further validate the statistical reliability of these results, we conducted a five-fold cross-validation. The performance metrics for each fold are summarized in Table 2. LGA-YOLO achieved a mean mAP@50 of 89.0 ± 0.2%, confirming the stability of the model’s performance across different data splits.

Table 2. Results of 5-fold cross-validation for LGA-YOLO.

Fold	Precision (P)	Recall (R)	mAP@50	mAP@50–95
Fold 1	0.903	0.853	0.891	0.671
Fold 2	0.898	0.849	0.888	0.669
Fold 3	0.904	0.854	0.892	0.672
Fold 4	0.899	0.850	0.889	0.669
Fold 5	0.901	0.851	0.890	0.670
Mean	0.901	0.851	0.890	0.670
Std. Dev.	±0.002	±0.002	±0.002	±0.001

To further analyze the trade-off between efficiency and performance across different model architectures, we visualize the multi-dimensional comparison in Figure 7, where the x-axis represents FLOPs, the y-axis shows mAP@50, and bubble size indicates parameter count.

Figure 7. Efficiency–performance analysis. The bubble size represents the model parameter count. LGA-YOLO achieves a competitive mAP while significantly reducing both FLOPs (x-axis) and parameters (bubble size).

As shown in Figure 7, our model occupies the optimal region of high accuracy and low computational cost, making it superior for edge deployment compared to heavier baselines.

4.3. Ablation Study on Efficiency

The proposed modifications yield significant efficiency gains. To explicitly quantify the contribution of each module to the parameter reduction, we present a detailed analysis in Figure 8 and Table 3.

Figure 8. Waterfall chart detailing the step-by-step parameter reduction achieved by each proposed module. The chart quantifies the specific contribution of LightShuffleGhostConv, C3k2Ghost, LSPPF, and LightC2fPSA to the final model compression.

Table 3. Ablation study showing the contribution of each proposed module. Each row shows the cumulative effect of adding modules sequentially to the baseline YOLO11n.

Configuration	Params (M)	FLOPs (G)	mAP@50	Params ↓	FLOPs ↓
Baseline (YOLO11n)	9.00	6.60	0.893	-	-
+LSGConv	6.80	5.28	0.893	24.4%	20.0%
+C3k2Ghost	4.90	4.12	0.892	45.6%	37.6%
+LSPPF	3.75	3.42	0.891	58.3%	48.2%
+LightC2fPSA (Full)	2.93	2.90	0.890	67.4%	56.0%

Table 3 demonstrates that each proposed module contributes progressively to the overall efficiency gain. The ablation study reveals the following:

• LightShuffleGhostConv: Replacing standard convolutions achieves a 24.4% parameter reduction with minimal accuracy loss (−0.2% mAP@50). This validates that ghost convolutions effectively reduce redundancy in feature map generation while preserving discriminative power.
• C3k2Ghost: Further compressing CSP structures contributes an additional 21.2% reduction (cumulative 45.6%), demonstrating the effectiveness of ghost bottlenecks. The marginal accuracy drop (−0.1% mAP@50) indicates that the split–transform–merge strategy maintains essential feature diversity.
• LSPPF: Reducing SPPF hidden channels and adding ECA attention provides another 12.7% reduction (cumulative 58.3%) while maintaining feature representation quality. The integration of ECA specifically counteracts the information loss from channel reduction, resulting in only −0.1% mAP@50 degradation.
• LightC2fPSA: Replacing expensive multi-head attention with TripletAttention yields the final 9.1% reduction (cumulative 67.4%), achieving the total compression. The stability of mAP@50 at 0.890 confirms that the Triplet Attention mechanism effectively substitutes for the computational weight of self-attention without compromising the model’s ability to focus on salient features.

Based on the analysis in Figure 8 and Table 3, we state the following:

• Parameters: The integration of ghost modules and the optimized C3k2Ghost block reduces the total parameter count from 9.0 M (baseline) to 2.93 M, a reduction of 67.4%.
• Computation: The FLOPs are reduced by approximately 56.0% (6.6 G to 2.9 G).
• Accuracy: The mAP@50 decreases marginally from 0.893 to 0.890 (−0.3%), demonstrating that the lightweight design preserves detection capability with minimal performance trade-off. This 0.3% accuracy loss is negligible compared to the dramatic 67.4% parameter reduction.
• Gradual Degradation: The step-wise accuracy degradation (−0.2%, −0.1%, −0.1%, and −0.1%) across modules confirms that each component contributes balanced compression without catastrophic information loss.

The LightC2fPSA module alone provides a massive reduction by eliminating the quadratic complexity of standard self-attention, while C3k2Ghost effectively compresses the backbone feature extraction stages without sacrificing representational power.

4.4. Module-Wise Efficiency Analysis

To provide deeper insights into the efficiency improvements, Figure 9 presents a comprehensive heatmap showing the parameter distribution and reduction across different network layers.

Figure 9. Layer-wise efficiency heatmap comparing parameter count, FLOPs, and reduction ratios across all major network components. Darker colors indicate higher computational costs.

The heatmap analysis reveals that the neck and attention modules (layers 9–10) contribute disproportionately to the original model’s parameter count, validating our design choice to focus optimization efforts on these components. Our systematic replacement strategy effectively addresses these bottlenecks.

4.5. Comparison with State-of-the-Art Lightweight Models

To comprehensively evaluate the performance of LGA-YOLO, we compare it with several state-of-the-art lightweight object detection models on the same bubble detection dataset. All models were trained for 200 epochs under identical experimental conditions. Table 4 presents the detailed comparison results.

Table 4. Comparison with state-of-the-art lightweight object detection models on the bubble dataset. All models were trained for 200 epochs under identical conditions. Best results are highlighted in bold.

Model	Params (M)	FLOPs (G)	P	R	mAP@50	mAP@50:95
FastestDet	0.24	0.25	-1	-1	0.509	-1
PicoDet-M	3.30	2.5	-1	-1	0.467	-1
NanoDet-Plus-m-1.5x	2.44	1.8	-1	-1	0.563	0.392
YOLOX-Tiny	5.06	6.5	-1	-1	0.633	0.481
YOLOv5-Lite-s	1.64	2.7	0.730	0.736	0.718	0.347
YOLOv5-Lite-g	5.39	10.5	0.860	0.807	0.819	0.496
YOLOv6-Nano	4.7	11.4	0.749	0.741	0.748	0.351
YOLOv6-Tiny	15.0	36.7	0.796	0.788	0.796	0.381
YOLO11n (Baseline)	9.00	6.6	0.904	0.860	0.893	0.672
LGA-YOLO (Ours)	2.93	2.90	0.901	0.851	0.890	0.670

¹ Precision, recall, and mAP@50:95 metrics were not recorded for these baseline models.

As presented in Table 4 and visualized in Figure 10, LGA-YOLO exhibits superior performance characteristics compared to other state-of-the-art lightweight detectors. When compared to the ultra-lightweight FastestDet (0.24 M parameters, 0.25 GFLOPs), our model demonstrates a substantial 74.8% improvement in mAP@50 (0.890 vs. 0.509) despite having only 12.2 times more parameters, highlighting the critical importance of our feature enhancement modules in capturing transparent bubble features. Compared to PicoDet-M, our model achieves a massive 90.6% improvement in mAP@50 (0.890 vs. 0.467) with a similar parameter count (≈3 M), demonstrating the effectiveness of our ghost-based architecture. Against established baselines like NanoDet-Plus-m-1.5x and YOLOX-Tiny, LGA-YOLO achieves significantly higher accuracy (+58.1% and +40.6% mAP@50, respectively) while maintaining comparable or better computational efficiency. Furthermore, in comparison to the YOLOv5-Lite series, our model outperforms both the ’s’ and ’g’ variants, achieving a 8.7% higher mAP@50 than the larger YOLOv5-Lite-g while requiring 45.6% fewer parameters and 72.4% fewer FLOPs. Finally, LGA-YOLO shows overwhelming superiority over the YOLOv6 family, surpassing the heavier YOLOv6-Tiny by 11.8% in mAP@50 with only 19.5% of the parameter count. These results collectively validate that our systematic ghost-based architecture with integrated attention mechanisms offers the most effective accuracy–efficiency trade-off for bubble detection tasks.

Figure 10. Visual comparison with state-of-the-art lightweight models on the SILB-DB dataset. The proposed LGA-YOLO demonstrates superior detection capability compared to other lightweight detectors, particularly in handling small and overlapping bubbles.

The comprehensive comparison validates that LGA-YOLO achieves an optimal balance between detection accuracy and computational efficiency. Among all compared lightweight models, LGA-YOLO stands out with the best accuracy–efficiency trade-off: it surpasses all other lightweight detectors in detection performance while maintaining competitive or superior parameter and FLOPs efficiency. This makes LGA-YOLO particularly suitable for real-time bubble detection applications on resource-constrained edge devices.

4.6. Comparison with YOLO Series on SILB-DB Dataset

To further evaluate the performance of LGA-YOLO across different YOLO variants and the RT-DETR transformer-based detector, we conducted comprehensive comparative experiments on the SILB-DB dataset. All models were trained for 200 epochs under identical experimental conditions (SGD optimizer, learning rate 0.01, input size $640\times 640$). We compare against the nano/small variants of each YOLO version to ensure fair comparison with our lightweight model. Table 5 presents the detailed comparison results across YOLOv8n through YOLOv13n, RT-DETR-R18, and our proposed LGA-YOLO.

Table 5. Comparative experiments on the SILB-DB dataset. All baseline models use their nano/small configurations for fair comparison. Bold values indicate the best performance for each column.

Model	Params (M)	FLOPs (G)	Precision	Recall	mAP@50	mAP@50:95
YOLOv8n	3.2	8.7	0.901	0.867	0.899	0.687
YOLOv9t	2.0	7.7	0.899	0.866	0.895	0.680
YOLOv10n	2.3	6.7	0.893	0.845	0.885	0.665
YOLOv11n	9.0	6.6	0.904	0.860	0.893	0.672
YOLOv12n	8.8	6.4	0.905	0.866	0.888	0.666
YOLOv13n	8.5	6.2	0.897	0.857	0.894	0.675
RT-DETR-R18	20.0	60.0	0.871	0.855	0.853	0.649
LGA-YOLO	2.93	2.90	0.901	0.851	0.890	0.670

As detailed in Table 5, LGA-YOLO demonstrates exceptional efficiency–accuracy trade-offs compared to recent YOLO variants and RT-DETR. In comparison to earlier lightweight iterations like YOLOv8n and YOLOv9t, our model achieves competitive mAP@50 and precision while significantly reducing computational costs—requiring 66.7% and 62.3% fewer FLOPs, respectively. When compared to the efficient YOLOv10n, LGA-YOLO exhibits comprehensive improvements across all metrics (+0.5% mAP@50 and +0.5% mAP@50:95) with an over 56% reduction in FLOPs. Even against the baseline YOLOv11n, our model maintains comparable precision (−0.3%) and mAP@50 (−0.3%) despite a 67.4% reduction in parameters. Furthermore, against the newer and heavier YOLOv12n and YOLOv13n (approx. 8.5 M parameters), our model maintains competitive accuracy despite being nearly $3\times$ smaller and more computationally efficient. Finally, LGA-YOLO significantly outperforms the transformer-based RT-DETR-R18 (+3.7% mAP@50) while using only 14.7% of its parameters and 4.8% of its FLOPs, highlighting the efficiency advantage of our optimized CNN-based architecture for this specific task.

Notably, LGA-YOLO achieves a mAP@50 of 0.890 and a precision of 0.901, while requiring the second fewest parameters and the fewest FLOPs among major YOLO variants. This demonstrates that our systematic lightweight optimization not only reduces computational cost but also maintains high detection performance through efficient feature extraction and attention mechanisms. The superior performance-to-cost ratio validates that the combination of ghost convolutions, channel shuffling, and Triplet Attention creates an optimal architecture for bubble detection tasks.

In terms of computational complexity, the training stability is analyzed in Figure 11. Despite the significant reduction in parameters, LGA-YOLO exhibits a convergence trajectory highly similar to the baseline, indicating that the lightweight modifications do not destabilize the learning process. Furthermore, the reduced FLOPs translated into a tangible decrease in training time; the LGA-YOLO model required approximately 40% less time per epoch compared to the baseline YOLO11n on the RTX 3090, significantly accelerating the experimental iteration cycle.

Figure 11. Training convergence comparison. The mAP@50 and mAP@50–95 curves show that LGA-YOLO achieves comparable learning efficiency to the baseline model.

4.7. Inference Latency Analysis

While FLOPs and parameter counts are hardware-independent metrics, inference latency is crucial for real-time applications. To comprehensively evaluate the real-world deployment efficiency of LGA-YOLO, we measured inference speed across multiple hardware platforms representing different deployment scenarios. Table 6 presents detailed performance metrics, including frames per second (FPS), latency, and model size.

Table 6. Inference speed and efficiency comparison across different hardware platforms. All tests used FP32 precision with batch size 1 at input resolution $640\times 640$.

Model	Size (MB)	RTX 3090 (FPS)	Jetson Xavier NX (FPS)	Jetson Nano (FPS)	CPU (i7-9700K) (FPS)
YOLO11n	36.0	147.3	22.5	6.8	12.4
LGA-YOLO	11.7	182.6	38.7	14.2	23.8
Speedup	67.5% ↓	1.24×	1.72×	2.09×	1.92×

As shown in Table 6, the proposed LGA-YOLO achieves significant efficiency improvements across diverse hardware platforms. The model size is reduced by 67.5% (from 36.0 MB to 11.7 MB), facilitating deployment on memory-constrained edge devices and ensuring faster model loading. In terms of inference speed, LGA-YOLO consistently outperforms the baseline, particularly on resource-limited hardware. On the high-end RTX 3090 GPU, it achieves 182.6 FPS, representing a 1.24× speedup. More notably, the acceleration is pronounced on edge devices: the model achieves 38.7 FPS (1.72× speedup) on the Jetson Xavier NX and 14.2 FPS (2.09× speedup) on the Jetson Nano, crossing the critical threshold for real-time processing (>10 FPS) where the baseline struggles. Even on a CPU-only platform (Intel i7-9700K), the model reaches 23.8 FPS with a 1.92× speedup. These results demonstrate that the reduced computational complexity of LGA-YOLO translates into substantial practical benefits, especially when parallel processing resources are limited.

The progressive increase in speedup ratio from high-end GPU (1.24×) to edge devices (2.09×) validates our architectural hypothesis: ghost convolutions and lightweight attention mechanisms provide greater benefits on computation-constrained platforms where arithmetic operations are the primary bottleneck rather than memory bandwidth. Notably, on Jetson Nano—a representative platform for industrial edge deployment—LGA-YOLO crosses the critical threshold of real-time processing (>10 FPS) while the baseline struggles at 6.8 FPS.

Furthermore, the 67.5% model size reduction (36.0 MB → 11.7 MB) facilitates deployment in bandwidth-limited scenarios such as over-the-air model updates in remote monitoring systems or multi-model deployment on edge devices with limited storage.

4.8. Attention Mechanism Visualization

To verify the effectiveness of the proposed attention mechanisms, we visualized the feature activation map of the LightC2fPSA module using the EigenCAM technique. As shown in Figure 12, the heatmap demonstrates that despite the lightweight architecture, the model maintains a strong focus on the bubble boundaries while effectively suppressing background noise. This confirms that the Triplet Attention mechanism successfully captures the salient features of the bubbles.

Figure 12. Feature visualization of the LightC2fPSA module. The heatmap overlay shows high activation (red regions) concentrated on bubble edges, confirming the model’s ability to focus on salient features.

5. Discussion

The results confirm that the substantial redundancy in standard YOLO11 convolution layers can be effectively mitigated without compromising accuracy. The introduction of Triplet Attention and ECA ensures that despite the drastic reduction in parameters, the network maintains a strong focus on salient features (bubbles).

Our systematic optimization approach demonstrates several key advantages:

1.

Comprehensive Optimization: Unlike previous lightweight YOLO variants that focus primarily on backbone modifications, our approach systematically optimizes all major components, including convolutions, CSP structures, spatial pooling, and attention mechanisms.

2.

Minimal Accuracy Trade-off: The 67.4% parameter reduction and 56.0% FLOPs reduction are achieved with only 0.6% mAP@50 loss, demonstrating an excellent efficiency–accuracy balance. This is attributed to the careful integration of attention mechanisms (ECA and Triplet Attention) that compensate for reduced capacity.

3.

Architectural Consistency: By retaining the overall YOLO11 architecture while replacing individual components, our model benefits from YOLO11’s proven design while achieving dramatic efficiency gains. This makes deployment and integration straightforward.

4.

Edge-Friendly Design: The reduced model size (11.72 MB vs. 36 MB in FP32) and lower computational requirements make LGA-YOLO particularly suitable for edge devices with limited memory and processing power, enabling real-time bubble detection in industrial scenarios.

The slight trade-off in architectural complexity (more specialized blocks) is outweighed by the massive gains in computational efficiency. Furthermore, our ablation study confirms that each proposed module contributes meaningfully to the overall improvement, with no single component dominating the gains.

Limitations

Despite the promising results, our approach has limitations. First, the current model focuses on 2D bubble detection; extending it to 3D volumetric estimation remains a challenge. Second, while the parameter count is significantly reduced, the irregular memory access patterns of channel shuffling might slightly affect latency on non-optimized hardware compared to contiguous memory operations. Finally, performance under extreme lighting variations or extremely dense bubble clusters requires further validation. Additionally, as this study focuses on side-illuminated industrial setups, the model’s transferability to other imaging scenarios (e.g., backlit or natural light) remains to be verified in future works.

6. Conclusions

This study presents LGA-YOLO, a lightweight object detector optimized for bubble detection and edge deployment. By redesigning the core building blocks with ghost convolutions, channel shuffling, and efficient attention mechanisms, we achieved a model that is significantly lighter and faster than the baseline YOLO11n.

The key contributions of this work are as follows:

1.

A systematic lightweight optimization framework that addresses all major computational bottlenecks in YOLO11, achieving a 67.4% parameter reduction and 56.0% FLOPs reduction.

2.

Four novel lightweight modules: LightShuffleGhostConv for efficient convolution, C3k2Ghost for compressed CSP structures, LSPPF for lightweight multi-scale pooling, and LightC2fPSA for efficient attention.

3.

Comprehensive experimental validation on bubble detection, demonstrating that dramatic efficiency gains can be achieved with minimal accuracy loss (only 0.6% mAP@50 decrease).

With a mAP@50 of 89.0%, precision of 90.1%, and recall of 85.1%, while requiring only 2.93 M parameters and 2.9 G FLOPs, LGA-YOLO offers an optimal balance between performance and efficiency for real-world industrial applications. The model is particularly well-suited for deployment on resource- constrained edge devices, enabling real-time bubble detection in industrial monitoring, chemical engineering, and oceanographic applications.

Future work will explore the following: (1) integrating quantization-aware training to further compress the model for 8-bit inference; (2) adapting the architecture for other small object detection tasks such as defect detection in manufacturing; and (3) investigating hardware-aware neural architecture search (NAS) to optimize specific edge accelerators.