Research on Rapid Detection of Underwater Targets Based on Global Differential Model Compression

Abstract

Large-scale deep learning algorithms have emerged as the primary technology for underwater target detection, demonstrating exceptional inference effectiveness and accuracy. However, the real-time capabilities of these high-accuracy algorithms rely heavily on high-performance computing resources like CPUs and GPUs. It presents a challenge for deploying them on underwater embedded devices, where communication is limited and computational and energy resources are constrained. To overcome this, this paper focuses on constructing a lightweight yet highly accurate deep learning model suitable for real-time underwater target detection on edge devices. We develop a new lightweight model, named YOLO-TN, for real-time underwater object recognition on edge devices using a self-constructed image dataset captured by an underwater unmanned vehicle. This model is obtained by compressing the classical YOLO-V5, utilizing a globally differentiable deep neural architecture search method and a network pruning technique. Experimental results show that the YOLO-TN achieves a mean average precision (mAP) of 0.5425 and an inference speed of 28.6 FPS on embedded devices, while its parameter size is between 0.4 M and 0.6 M. This performance is a fifth of the parameter size and twelve times the FPS of the YOLO-V5 model, with almost no loss in inference accuracy. In conclusion, this framework significantly enhances the feasibility of deploying large-scale deep learning models on edge devices with high precision and compactness, ensuring real-time inference and offline deployment capabilities. This research is pivotal in addressing the computational challenges faced in underwater operations.

1. Introduction

With the development of artificial intelligence, humanity is increasingly relying on highly automated unmanned underwater devices to assist in underwater operations, such as ocean exploration, resource exploration, and environmental protection [1,2,3]. Therefore, the development of an underwater object recognition (UOR) algorithm has increasingly attracted attention. However, the underwater environment presents unique challenges for object recognition, being characterized by poor lighting, turbid water, and physical properties significantly different from terrestrial settings. These conditions severely impact the efficacy of conventional recognition systems, necessitating specialized approaches for reliable performance.

In the realm of underwater object recognition, sonar and imaging systems are the two primary technologies that provide direct and effective methods for identifying and mapping underwater environments and objects. Sonar is widely used for deep-sea navigation, military defense, and mapping, thriving in low-visibility conditions [4,5,6,7]. Conversely, optical imaging excels in well-lit shallow waters, and is favored for its ability to capture detailed information, making it widely used in various marine engineering applications such as environmental monitoring, fisheries management, and underwater exploration and monitoring.

In underwater environments, the quality of the optical image is significantly affected by factors such as light scattering, absorption, and particles. In response, underwater image enhancement methods have been developed, including conventional physical and statistical methods [8,9,10], data-driven convolutional neural networks, and generative algorithms [11,12,13]. As a crucial step in enhancing the performance of underwater object recognition, it directly promotes the effectiveness and practicality of recognition algorithms by improving image quality. In this work, based on the characteristics of our self-constructed underwater image dataset, we choose simple and effective image enhancement methods to meet the requirements for deployment on terminal devices.

The development of UOR algorithms is driven by advancements in computer vision technologies. Existing UOR algorithms can be roughly divided into two types. The first type is handcrafted feature-based algorithms, which rely on domain experts to design features that effectively represent the target based on the characteristics of the specific task or dataset. For example, color features, texture features, shape features, and their fusion, combined with various machine learning methods and statistical models, have been widely used for underwater object recognition [14,15,16,17,18]. The second one comprises deep learning methods, which have gradually become mainstream for UOR with the development of high-performance hardware devices and computer vision technologies [19]. By contrast, deep-learning-based target recognition algorithms exhibit high detection accuracy and strong generalization capabilities, such as the two-stage R-CNN and its derivative approaches [20,21,22,23,24,25,26,27], as well as the single-stage YOLO series algorithm [28] and SSD method [29] and so forth. As a benefit of this, underwater target recognition has also made significant progress [1,2,3]. However, the unparalleled inference performance of deep neural networks comes at the cost of vast memory consumption and high computational complexity. For instance, in two-stage object detection algorithms, the simplest AlexNet [30] requires 61 million parameters, 731 million floating-point operations, and 233 MB of memory. And even though some simplified one-stage object recognition methods could meet real-time requirements on some edge devices ($FPS\ge$ 25 [31]), there is still potential to reduce computational complexity and model size, providing more possibilities for offline deployment on terminal devices. In underwater target recognition, electromagnetic waves experience significant attenuation in the underwater environment, making it difficult to transmit data to servers for processing. In addition, unmanned underwater devices equipped with underwater target systems are typically resource-constrained embedded devices. Implementing data collection, transmission, storage, preprocessing, and object recognition within such limited resource constraints imposes stricter requirements on both the size and accuracy of the object recognition model.

Deep neural network model compression techniques can reduce the number of model parameters, save the model’s memory, and accelerate computations. Recently, there has been considerable progress in model-compression-related work, with various methods such as network pruning [32,33,34,35], parameter quantization [36,37,38,39], lightweight module design [40,41], and knowledge distillation continuously emerging [42,43,44,45,46,47,48,49]. In previous work conducted by our research group, a globally differentiable deep neural architecture search method [50] was proposed for lightweight classical CNN models. This method introduces the knowledge of the teacher network into the network search, then automatically searches for a student network more sensitive to the teacher network’s knowledge. The student network is able to replace the teacher network to perform the original task in some resource-constrained devices. On the basis of 0.7% of the original model, the accuracy of the student model constructed by this method can be kept within 1%.

In this study, utilizing this network architecture search algorithm based on global gradients, we design a lightweight underwater target recognition model constructed through a teacher-guided neural architecture search named YOLO-TN. This model is successfully deployed on embedded devices underwater, ensuring both high accuracy in model detection and resolution of computational conflicts. Furthermore, the construction and processing methods for a realistic underwater environment dataset proposed in this paper address challenges associated with imbalanced target quantities, a singular image environment, and unclear images in real underwater environments.

The main contributions of this paper are summarized as follows:

• A lightweight model named YOLO-TN is designed for underwater target recognition. Experimental results demonstrate that the YOLO-TN model achieves an [email protected] of 0.5425 after extreme compression with an input size of 416 × 416. This represents a reduction of less than 1% compared to YOLO-V5s. Moreover, the inference FPS reaches 28.8 on the CPU, effectively realizing high accuracy and lightweight characteristics for the underwater target recognition model. This ensures the feasibility of offline deployment and real-time inference of the model.
• Through the construction and processing methods of a realistic underwater environment dataset, issues such as imbalanced target quantities and a singular image environment in existing underwater datasets are mitigated. Additionally, we analyze challenges present in underwater datasets, including inadequate underwater illumination, image degradation, and blurring. For different real underwater environments, this paper proposes preprocessing techniques, including dark channel dehazing, underwater image color restoration, and automatic color balance algorithms. These methods effectively enhance the quality of underwater datasets, improving the model’s generalization.
• Deploying the YOLO-TN model to the Jetson TX2 embedded platform using the MNN inference engine, a real-time underwater target offline recognition system is established. Test results indicate that the FPS of the YOLO-TN network ensures real-time performance. The pruned YOLO-TN achieves an FPS of 28.6 and 20.4 at input sizes of 320 × 320 and 416 × 416, respectively.

The remainder of the paper is organized as follows: Section 2 provides the method of building the model. Section 3 introduces the model’s performance on public datasets. In Section 4, the model is deployed on a device and evaluated in real experiments. Section 5 concludes and discusses this paper.

2. Model Construction

In this work, we employ a globally differentiable deep neural architecture search method and integrate the teacher network’s knowledge into the search process. The method automatically identifies a student network that learns more from the teacher network. This student network can replace the teacher network on resource-constrained devices while maintaining similar performance. We use the Differentiable ARchiTecture Search (DARTS) method for the architecture search [51]. Unlike inefficient black-box searches, DARTS leverages gradient-based optimization to achieve comparable performance with fewer computational resources. This lightweight architecture search builds a compact model with low storage requirements, low computational complexity, and high performance. Parameter pruning further reduces redundancies in the trained model, resulting in a small, fast, and accurate offline recognition model for underwater targets. This improved lightweight model is called “YOLO-TN”.

In the search process using the globally differentiable deep network architecture search compression algorithm [50], the search space is defined as having 3 × 3 depthwise separable convolution, 5 × 5 depthwise separable convolution, 3 × 3 dilated convolution, 5 × 5 dilated convolution, 3 × 3 max pooling, 3 × 3 average pooling, and skip connections. This determines the operations between different nodes in the basic computing unit. To better recognize small targets, operations in the search space minimize the size and stride of convolution kernels, avoiding the omission of feature extraction for some small targets. Therefore, all operation strides are set to 1 in the search space. The final architecture consists of operations present in the search space. A schematic diagram of the method used in this paper is shown in Figure 1.

2.1. Loss Function

The total loss function for the network is represented as follows:

$$L_{YOLO}=\sum _i^N\left({\lambda }_1{L}_{CIoU}+{\lambda }_2{L}_{conf}+{\lambda }_3{L}_{cls}\right)$$

(1)

where $L_{CIoU}$, $L_{conf}$, and $L_{cls}$ denote the bounding box loss, confidence loss, and classification loss, respectively. ${\lambda }_1$, ${\lambda }_2$, and ${\lambda }_3$ are the weights for the three losses. To prevent “learning” from predicting the background region, in YOLO’s distillation, the distillation loss is formulated as an objective scale function. The student network learns bounding box coordinates and target class probabilities only when the teacher network predicts a high confidence for an object. The guided confidence loss for distillation is represented as follows:

$$\begin{array}{c}\hfill L_{conf}^{Comb}(o_i^{gt},{\widehat{o}}_i,o_i^T)=\underset{\mathrm{Distection}\mathrm{loss}}{\underbrace{L_{conf}(o_i^{gt},{\widehat{o}}_i)}}+\underset{\mathrm{Distillation}\mathrm{loss}}{\underbrace{{\lambda }_D·L_{conf}(o_i^T,{\widehat{o}}_i)}}\end{array}$$

(2)

where ${\widehat{o}}_i$ is the predicted confidence of the student network, $o_i^{gt}$ is the true confidence label, and $o_i^T$ is the predicted confidence of the teacher network. The classification loss for the student network is as follows:

$$\begin{array}{c}\hfill L_{cls}^{Comb}\left(p_i^{gt},{\widehat{p}}_i,p_i^T,\widehat{o_i^T}\right)=L_{cls}\left(p_i^{gt},{\widehat{p}}_i\right)+\widehat{o_i^T}·{\lambda }_D·L_{cls}\left(p_i^T,{\widehat{p}}_i\right)\end{array}$$

(3)

where ${\widehat{p}}_i$ is the predicted probability of the student network containing the target in the predicted box, $p_i^{gt}$ is the true value of the target category, and $p_i^T$ is the predicted probability of the teacher network containing the target in the predicted box. Similarly, the bounding box loss for the student network is represented as follows:

$$\begin{array}{c}\hfill L_{CIoU}^{Comb}\left(b^{gt},{\widehat{b}}_i,b_i^T,{\widehat{o}}_i^T\right)=L_{CIoU}\left(b_i^{gt},{\widehat{b}}_i\right)+{\widehat{o}}_i^T·{\lambda }_D·L_{CIoU}\left(b_i^T,{\widehat{b}}_i\right)\end{array}$$

(4)

where ${\widehat{b}}_i$ is the predicted box coordinates of the student network, $b_i^{gt}$ is the true bounding box coordinates, and $b_i^T$ is the predicted box coordinates of the teacher network. Overall, in the improved loss function, knowledge of the teacher model in detecting the target is added, and the predictions for the background units are discarded. The total loss function during training is represented as follows:

$$\begin{array}{c}\hfill L_{YOLOKD}=L_{conf}^{Comb}\left(o_i^{gt},{\widehat{o}}_i,o_i^T\right)+L_{cls}^{Comb}\left(p_i^{gt},{\widehat{p}}_i,p_i^T,\widehat{o_i^T}\right)+L_{CloU}^{Comb}\left(b^{gt},{\widehat{b}}_i,b_i^T,{\widehat{o}}_i^T\right).\end{array}$$

(5)

During the dual-layer optimization process, $L_{YOLO-KD}$ is used to optimize the network parameters w.

In optimizing the architecture $\alpha$ and simultaneously searching for the backbone network of the underwater target recognition model, the sigmoid function is used instead of SoftMax, to avoid the phenomenon of skip connection enrichment during the search phase. To make the distinction between different operations more pronounced and to enhance the binary nature of the architecture weights, a 0–1 loss is introduced to ensure that $\sigma \left({\alpha }_i\right)$ are closer to 0 or 1. Using the weight coefficient $w_{0-1}$ to control the intensity of the 0–1 loss, the total loss for the searching architecture $\alpha$ is as follows:

$$\begin{array}{c}\hfill L_{\alpha -total}={\mathcal{L}}_{val}(w^{♭}\left(\alpha \right),\alpha )+w_{0-1}{L}_{0-1}\end{array}$$

(6)

where $L_{0-1}$ is the 0–1 loss.

2.2. Construction of the Student Model

For a deep neural network performing classification tasks, we stack a super net at the cell level. This super net serves as the search space for finding the optimal cell, thus obtaining the most suitable super net. We similarly stack a super net shaped like YOLO to search for an architecture $\alpha$ suitable for underwater datasets in the context of underwater object recognition networks.

In constructing the super net for object recognition tasks, we perform downsampling at appropriate computational nodes to obtain different receptive fields and improve the recognition of small underwater objects. This approach is similar to the original YOLO framework. In YOLO-V5, a 32× downsampling of the feature map is achieved through five convolution operations. Similarly, for our super net, we use 32× downsampling. This requires three ordinary convolutional layers and two basic computational units. The structure is shown in Figure 2.

The basic computational unit is divided into two types: Normal and Reduce. Similarly, at depths of 1/3 and 2/3 of the network, Reduce computational units are set, and the rest are Normal computational units. Stacking these basic computational units, the backbone network of the underwater target recognition network is formed. In this paper, the lightweight backbone network obtained through the neural architecture search is named the “TN” (teacher-guided neural architecture search) module. After obtaining the lightweight backbone network TN, similar to in YOLO-V5, detection heads are placed at downsampling positions of 32×, 16×, and 8× in the entire object recognition network’s feature maps to obtain the model structure of YOLO-TN.

2.3. Parameter Pruning

To compress the underwater target recognition model and improve inference frames per second (FPS), we apply a pruning algorithm to drastically trim the detection head of YOLO-TN. This paper introduces a simple-yet-effective pruning method. L1 regularization is applied to the scaling factors in the Batch normalization (BN) layer, pushing them toward zero to identify irrelevant channels [47]. After pruning, any accuracy loss can be mitigated through retraining.

2.4. Evaluation Criteria

This study aims to deploy the model to resource-constrained embedded systems, necessitating additional metrics. Floating-Point Operations per Second (FLOPs) represents the floating-point operations required by the network, indicating the computational load. A lower FLOPs value for image processing on a particular device implies that it can process more images in the same time frame. Frames per second (FPS) is a common concept in object recognition and image processing. In the domain of object recognition, a higher FPS implies that more images can be detected per second, ensuring better real-time performance.

The number of parameters represents the sum of all parameters that need to be trained during model training. It determines the model’s size, affecting the memory or GPU memory it occupies. Generally, a smaller number of model parameters results in fewer FLOPs, less storage space required to save the model, and lower hardware requirements.

In object recognition tasks, evaluating a model’s performance is challenging as it often involves classifying multi-label images. Mean average precision (mAP) is a widely used metric to assess model performance in object recognition tasks. mAP represents the average value of Average Precision (AP) for each category, where AP is the Average Precision that evaluates the detection performance for a specific class. It is calculated as the area under the Precision–Recall curve. By computing the AP for each class, summing them, and then taking the average, the mAP value can be obtained. mAP can be further categorized based on different Intersection over Union (IoU) thresholds, such as [email protected] (IOU threshold is 0.5) to [email protected].

3. Model Validation

This study conducts experiments using a multi-GPU training and single-GPU/CPU inference mode. The hardware setup is as follows:

Server Configuration:

-

CPU: Intel(R) Xeon(R) Silver 4110;

-

Memory: 36 GB DDR4;

-

GPU: Nvidia 2080TI.

Software Configuration:

-

Ubuntu 18.04;

-

PyTorch 1.9.0;

-

CUDA 11.2.

The experiment begins by using the architecture obtained from the super net as the basic building block. Different experiments are conducted by stacking various parameters to validate the model performance and inference speed of the YOLO-TN model under different parameter settings. The dataset used is the fish–trash dataset officially included in the YOLO collection. This dataset contains 1823 clear images of plastic waste and fish.

The experimental results confirm that the architecture obtained using the network architecture search method in this paper exhibits superior performance on the given dataset compared to conventional search methods and is more lightweight. In the comparison search experiment, the network input image size is set to 640 × 640 and the batch size to 128. The search lasts for 300 epochs, with 10 initial stack basic units and 16 initial channels. After comparative search experiments, the optimal search architecture suitable for a real underwater dataset is obtained. The Normal and Reduce computation units constructed using this architecture are shown in Figure 3.

After determining the structure of the basic computational unit for the offline underwater target recognition algorithm, further experiments are conducted by varying the input channels and the number of basic units in different cells. The goal is to develop a lightweight underwater target recognition network with excellent performance. The experimental results are shown in

Table 1. Experimental results for different initial channels and basic unit numbers.

Model	Cell Number	Initial Channel	[email protected] (Undistilled/Distilled)	Parameter (M)	FPS (GPU/CPU)	FLOPs (G)
YOLO-TN(a)	10	8	0.5038/0.5205	2.8704	112.7/9.8	7.8
YOLO-TN(b)	10	16	0.5312/0.5441	3.0516	109.4/7.7	9.1
YOLO-TN(c)	7	16	0.5326/0.5437	1.2083	134.5/8.9	3.9
YOLO-TN(d)	5	16	0.5355/0.5471	0.9481	162.7/10.2	3.5
YOLO-TN(e)	4	16	0.5384/0.5592	0.8401	176.3/14.1	3.3
YOLO-V5s	-	-	0.5495/-	7.2	178.9/8.3	16.5

. From Table 1, it is evident that replacing the backbone network of YOLO-V5 with the TN module results in a significant reduction in both parameter count and FLOPs compared to the YOLO-V5s network. The most substantial reduction is observed in YOLO-TN(e), where the model parameters are only 11.67% of YOLO-V5s. Interestingly, the [email protected] value for YOLO-TN(e) is 0.97% higher than that of YOLO-V5s.

When comparing YOLO-TN(a) and YOLO-TN(b), increasing the initial channels significantly enhances [email protected]. However, it also leads to a decrease in FPS and an increase in FLOPs, which is not favorable for real-time inference on embedded devices. Similarly, increasing the number of cell units may hinder the ability to extract features from small targets, while too few units can compromise the effectiveness of the super network. Balancing model effectiveness and real-time inference, we choose YOLO-TN(e) with only four basic computational units (already sufficiently small) and an initial channel of 16 for further compression. The structure of YOLO-TN(e) is illustrated in Figure 4.

Later, the network structure undergoes parameter pruning for the final extreme compression. Pruning rates ranging from 0.4 to 0.8 with a step size of 0.1 are set. This paper explores the effects of channel pruning based on BN layer coefficients and convolutional kernel pruning based on the L2 norm (referred to as prune-A and prune-B). Through analysis of experimental results, it is observed that models pruned using the prune-A strategy generally exhibit higher accuracy than the other strategy under the same pruning rate. Moreover, at a pruning rate of 0.5, it achieves the optimal [email protected] value in the experiment.

As observed in Figure 5, the lightweight network proposed in this paper, YOLO-TN, achieves a smaller parameter count and faster inference speed compared to the benchmark models. Considering both [email protected] value and inference speed, the YOLO-TN model pruned using strategy prune-A at a pruning rate of 0.5 stands out as the optimal choice, striking a balance between model recognition accuracy and real-time performance. Finally, we apply the complete network structure to the dataset, and the training results are compared with that of YOLO-V5s, as illustrated in Figure 6.

In Figure 6, the training data for YOLO-TN-prune-A-0.5 are compared with those of YOLO-V5s using the fish–trash dataset. The [email protected] curve indicates that the lightweight network rapidly achieves a model with superior performance. The loss curve demonstrates that the training loss, guided by the teacher network, decreases more rapidly and converges earlier. This is attributed to the lightweight nature of the model, facilitated by the depthwise separable convolutional structure, allowing for swift learning of sample features and parameter updates.

At an input image size of 640 × 640, YOLO-TN’s FPS outperforms the listed models in this paper. Nevertheless, for devices with limited resources, ensuring real-time predictions remains challenging. Therefore, training is performed by reducing the input image size, and the model’s performance is tested with reduced input dimensions of 416 × 416 and 320 × 320. The results are presented in

Table 2. Model experiment results with different input sizes.

Model	Input Size	[email protected]	FPS (GPU/CPU)	FLOPs (G)
YOLO-TN-640	640 × 640	0.5592	176.8/17.2	3.3
YOLO-TN-416	416 × 416	0.5425	176.9/28.8	2.8
YOLO-TN-320	320 × 320	0.5101	177.6/38.4	2.8

.

The experimental results indicate that, when the input size is reduced to 320 × 320, the model achieves 38.4 FPS and an [email protected] of 0.5101. Real-time performance is significantly improved compared to the original network, making it suitable for offline devices with smaller resources. At the same time, different scales of input can be selected according to different needs.

4. Engineering Experiment

4.1. Evaluation Criteria

To simulate a real underwater environment, most of the dataset used in this study came from Qiandao Lake in Hangzhou, Zhejiang Province, which has a depth of up to 200 m, and a small part came from a scenic fish pond north of the city. Since our acquisition equipment, the Youcan BW SpacePro underwater drone, is not allowed to work in too-deep underwater conditions, the data are captured at depths of 0.5–30 m. The drone is equipped with a SONY 4k high-definition camera. The video is recorded at a resolution of 1920 × 1080, the number of frames per second is extracted, and 5964 valid images are obtained, as shown in Figure 7. Considering the size and number of targets in the training sample, the acceptance field and the number of layers of the network are analyzed. However, the underwater environment degrades the image due to the attenuation of scattered and absorbed light, resulting in illumination attenuation, blurring, and low contrast. To mitigate these problems, especially in underwater target recognition missions, image recovery is key for preventing false positives.

4.2. Data Preprocessing

This paper uses the dark channel dehazing algorithm [52] to address image degradation, blurring, and low visibility in turbid underwater images. The underwater color restoration algorithm [53], which accounts for visible light attenuation, is applied to correct image degradation from insufficient lighting and restore the original color. An automatic color balance algorithm [54] is also used to correct color distortion in deep underwater conditions. After processing, the image’s color histogram ratio becomes similar to that of the surface environment. These image processing algorithms are applied as preprocessing steps during the training phase to enhance the dataset and improve model generalization. The image enhancement effect is shown in Figure 8.

4.3. Model Application

The processed dataset is used for training in the network, and the training results of YOLO-TN-Prune-A0.5 and YOLO-V5s are shown in Figure 9.

In this study, YOLO-V5s, unpruned YOLO-TN, and pruned YOLO-TN models with three input sizes are selected as experimental models. After converting the experimental models uniformly from .pth format to .mnn format, they are loaded into the MNN inference framework for inference experiments. The experimental results are shown in

Table 3. MNN inference framework’s inference FPS on TX2.

Model	Input Size	FPS (CPU)
Pruned YOLO-TN-640	640 × 640	10.8
Pruned YOLO-TN-416	416 × 416	20.4
Pruned YOLO-TN-320	320 × 320	28.6
Unpruned YOLO-TN	640 × 640	8.9
YOLO-V5s	640 × 640	2.4

.

The YOLO-TN, with an input size of 320 × 320, achieves real-time performance in inference and simultaneously ensures good recognition results. This suggests that the model can be deployed on the Jetson TX2 to complete a real-time underwater object recognition system. Figure 10 displays the recognition results of YOLO-V5, unpruned YOLO-TN, and YOLO-TN with different input sizes in different scenarios. It can be observed that, at an input size of 320 × 320, the pruned YOLO-TN recognizes a similar number of objects with accuracy comparable to YOLO-V5s. In terms of inference speed, its FPS is nearly 12 times that of YOLO-V5s.

5. Conclusions and Discussion

This paper solves the challenge of the high computing requirement of underwater offline recognition and makes it effective for offline embedded equipment. We propose an enhanced lightweight underwater target network and establish a real-time underwater target offline recognition system. We construct a feature extraction network with fewer parameters using a specialized network search algorithm, replacing the backbone of YOLO-V5. By applying various compression methods and parameter pruning, we ultimately develop the lightweight target detection model YOLO-TN. Additionally, we collect a dataset under real underwater conditions, addressing challenges such as the scarcity of underwater target datasets, single-image targets, overly idealized collection environments, and excessively static targets. In view of the limited computing power of the terminal, this paper uses a variety of simple and effective image enhancement algorithms to enhance the dataset. Based on this, we establish a real-time underwater target offline recognition system. This system, deployed on the NVIDIA Jetson TX2 embedded platform using the high-performance inference framework MNN, achieves real-time inference for underwater targets. Video recognition experiments are conducted to test the model’s performance under different input sizes. Results show that the lightweight model maintains recognition accuracy while achieving real-time inference speeds.

However, there are still some limitations in our work. First, improving the lightweight structure search method. The proposed lightweight network architecture search method requires setting two hyperparameters—number of layers and initial channels—when constructing the final network, which may cause the network to fall into a local optimum. Second, the dataset in this paper was collected from a fixed water area, with the acquisition equipment set to fixed parameters, which may lead to limited data diversity. Therefore, in future work, we will continue to expand the dataset by considering factors such as different climatic environments, lighting conditions, water areas, and depths to further enhance data diversity.