GFANet: An Efficient and Accurate Water Segmentation Network

Abstract

Accurate water body detection is essential for autonomous navigation and operational planning of unmanned surface vehicles (USVs). To address model adaptability to ambiguous boundaries caused by diverse scenarios and climatic conditions, this study proposes GFANet (Global–Local Feature Attention Network) for the real-time water surface semantic segmentation of camera-captured images. First, a Global–Local Feature (GLF) extraction module is proposed, integrating a self-attention-based local feature extractor and a multi-scale global feature extractor for parallel feature learning, thereby enhancing hierarchical feature representation. Second, a Gated Attention (GA) module is designed with a dual-branch gating mechanism to implement noise suppression and efficient low-level feature utilization. The method was validated on three publicly available datasets in relevant domains. The experimental results on the Riwa dataset show that GFANet achieves state-of-the-art segmentation performance (4.41 M parameters, 7.15 GFLOPs) with an mIoU of 82.29% and an mPA of 89.49%. Comparable performance metrics were obtained on the USVInland and WaterSeg datasets. Additionally, GFANet achieves a 154.98 FPS processing speed, meeting real-time segmentation requirements. The experimental results verify that GFANet achieves an optimal balance between high segmentation accuracy and real-time processing efficiency.

1. Introduction

Water body segmentation holds significant application value in environmental governance policies and advancements in USV technologies. In the context of environmental monitoring, real-time water detection enables hydrological disaster monitoring through water body segmentation [1,2,3]. For autonomous systems, the precise delineation of water bodies is essential for vessel navigation [4,5,6]. Recently, applications of water body segmentation have been further expanded to include ecosystem assessment [7,8] and climate change impact analysis [9].

Traditional sensors, including contact-based devices, radar, and sonar, face inherent limitations: Contact sensors are restricted to static scenarios with short-range detection, while radar and sonar suffer from noise artifacts due to fog, reflections, or turbulent waves. In contrast, optoelectronic cameras offer a cost-effective alternative but demand advanced vision algorithms to address complex environmental interference.

This study addresses the machine vision-based identification of water regions in outdoor scenes, which is critical for intelligent video surveillance in aquatic environments. Furthermore, water surface segmentation represents a quintessential case of complex image segmentation, providing insights into broader segmentation challenges. Existing water body segmentation methodologies are typically classified into image processing-based and machine learning-based frameworks. Image processing frameworks depend on empirical features (e.g., gradients, textures, edges), which exhibit limitations in generalizability and robustness. For instance, Zhao et al. [10] employed an adaptive-threshold Canny edge detection algorithm for river boundary detection. However, these frameworks demand a priori environmental knowledge and exhibit performance degradation under substantially varying conditions. With the proliferation of deep learning, machine learning-based frameworks have been deployed for water body segmentation. For example, Zhan et al. [11] developed an online learning framework, leveraging Convolutional Neural Networks (CNNs) for water region detection in unknown navigation scenarios. Han et al. [12] pioneered the use of Fully Convolutional Networks (FCNs) for urban flood segmentation. Although these frameworks attain high accuracy, their computational complexity poses significant hardware demands.

Most state-of-the-art deep learning-based water segmentation frameworks require significant computational resources. Given practical deployment constraints and real-time inference requirements, this study proposes a network architecture that balances segmentation accuracy with computational efficiency. The primary challenge involves balancing model parameter complexity and inference efficiency. Therefore, designing a lightweight yet accurate segmentation network specifically optimized for water region recognition has significant academic and practical implications.

The key contributions of this work are as follows:

• A Global–Local Feature (GLF) extraction module is proposed to enhance hierarchical feature representation within network depth and width constraints, thereby improving segmentation performance.
• A Gated Attention (GA) module is designed with skip connections to enable efficient feature utilization, enhancing segmentation accuracy and interference robustness.
• GFANet is implemented using a lightweight backbone integrated with the proposed modules. Under standardized training protocols, GFANet achieves segmentation accuracy comparable to complex models while demonstrating fewer parameters, lower computational complexity, and faster inference speed.

2. Related Work

Deep learning-driven image semantic segmentation has established itself as a prominent research domain in the past decade. Although deep learning-based segmentation has been widely adopted in autonomous driving for lane detection, its application to complex water body segmentation scenarios remains significantly underexplored, offering a promising research trajectory with substantial potential.

2.1. Feature-Enhanced Image Segmentation

The accurate segmentation of complex boundaries and ambiguous edges poses significant challenges. Continuous advancements in feature representation learning have improved segmentation performance. UNet [13] employs skip connections for multi-level feature fusion, integrating high-resolution shallow encoder features with deep decoder semantic features via channel-wise concatenation to preserve local details and global context. Traditional CNNs, constrained by limited receptive fields, face challenges in modeling long-range dependencies. PSPNet [14] addresses this limitation with a pyramid pooling module, which downsamples feature maps via multi-scale pooling, followed by bilinear upsampling and concatenation to enable explicit global context modeling. Concurrently, the DeepLab series [15] pioneered dilated convolutions, exponentially expanding receptive fields by adjusting dilation rates without parameter increase.

However, uncontrolled receptive field expansion risks local detail loss, introducing a trade-off between global and local feature representation. To resolve this, BiSeNet [16] introduced a dual-path architecture incorporating a feature fusion module with channel attention weighting to balance speed and accuracy. DANet [17] pioneered a dual-attention mechanism that captures channel correlations using covariance matrices and adaptively fuses outputs via learnable parameters, thereby improving segmentation precision for complex boundaries. CCNet [18] further optimized computational efficiency through a recursive criss-cross attention mechanism. This architecture aggregates contextual information along horizontal/vertical axes via two sequential criss-cross attention modules, concatenated with local feature maps to achieve superior segmentation performance.

These works demonstrate that integrating local and global semantic features is essential for segmenting complex boundaries. Building on this foundation, GFANet integrates two novel modules—Global–Local Feature Fusion (GLF) and Global Attention (GA)—to enhance semantic segmentation performance.

2.2. Water Body Segmentation

Early water body segmentation was primarily based on handcrafted features and a priori knowledge. Rankin et al. [19] developed classification rules using color and texture analysis, though generalization remained limited by scene-specific lighting and terrain variations. Yao [20] proposed a hybrid framework integrating region growing and texture analysis: initial segmentation using brightness thresholds, followed by K-Means clustering on 9 × 9 image patches to identify water regions via minimal texture variance. However, shadow interference required stereo vision, thereby increasing computational complexity. To reduce manual intervention, Achar et al. [21] developed a self-supervised algorithm leveraging RGB, texture, and elevation features for patch-level binary classification, aiming to reduce manual intervention. However, missegmentation persisted in complex boundary regions.

With the proliferation of convolutional neural networks (CNNs), data-driven methodologies gained prominence. Elias et al. [22,23] pioneered encoder-decoder architectures for Unmanned Surface Vehicle (USV) water detection, achieving real-time segmentation. However, single-scene training limited architectural generalization. Eltner et al. [24] integrated CNN segmentation with structure-from-motion (SfM) for 3D water level measurement. However, cross-river applications necessitated manual parameter calibration. Blanch et al. [25] addressed this limitation by training a universal CNN on multi-basin heterogeneous datasets, achieving significant improvements in cross-regional river segmentation. Cao et al. [26] and Miao et al. [27] proposed high–low feature connection methods but neglected receptive field mismatches. Meanwhile, Liang et al. [28] enhanced Deeplabv3+ for USV navigable area detection, improving the F1-score by 6.8% over baselines.

Recent advancements have focused on lightweight hybrid architectures to balance segmentation accuracy and computational efficiency. Kang et al. [29] developed CoastFormer, incorporating axial attention in the encoder to capture long-range coastline features while maintaining high-resolution outputs using a CNN decoder. Zhang et al. [30] developed MSF-Net, leveraging complementary infrared and visible-light data to enhance turbid water detection, thereby achieving a Dice coefficient of 91.5%.

Notwithstanding these advancements, key challenges remain: limited discriminative capability under complex lighting and turbid conditions, and the challenge of balancing lightweight designs with high segmentation precision. This study introduces a multi-modal adaptive network featuring dynamic feature selection and hierarchical attention mechanisms to balance robustness and real-time computational performance.

3. Materials and Methods

To address the speed–accuracy trade-off in practical applications, this study introduces GFANet (Global–Local Feature Attention Network), a lightweight architecture designed for real-time water surface semantic segmentation. GFANet employs an encoder–decoder architecture comprising three core components: (1) a backbone, (2) a Global–Local Feature (GLF) extraction module, and (3) a Gated Attention (GA) module.

3.1. Backbone

A lightweight and efficient backbone was developed to enhance inference speed. Ma et al. [31] developed ShuffleNetV2, demonstrating its superiority over competing lightweight architectures. While ShuffleNetV2 was proposed several years ago, its lightweight design principles remain a foundational guideline for efficient module architecture. Contemporaries such as MobileNet and EfficientNet continue to see widespread engineering applications, whereas extensive studies [32,33] have validated ShuffleNetV2’s superior hardware-friendly architecture and memory access efficiency compared to these counterparts. Therefore, to satisfy real-time inference requirements, ShuffleNetV2 was adopted as the backbone architecture.

The main design of ShuffleNetV2 includes the basic unit for feature representation, as shown in Figure 1a, and the down unit for downsampling, as shown in Figure 1b. In the basic unit, the input with c feature channels undergoes channel splitting into two branches. One branch preserves the identity mapping, while the other branch applies three convolutions with consistent input/output dimensions. The branch outputs are concatenated, maintaining channel count consistency. Channel shuffle is employed to fuse features and facilitate inter-branch communication. In the down unit, channel splitting is omitted, and the convolution stride is increased to double the output channels while halving spatial resolution.

Based on these two fundamental units and with reference to the design of ShuffleNet V2, we constructed the encoder backbone, as depicted in Figure 2. The encoder consists of four downsampling stages. The first stage involves feature transformation and extraction using a downsampling convolution, followed by max pooling. Subsequent feature extraction is carried out through three additional downsampling stages, which capture deeper semantic information. To ensure model efficiency and a lightweight design, the last three downsampling stages uniformly utilize one downsampling unit and three basic units. Feature maps from each downsampling stage are retained for skip connections.

Corresponding to the encoder, the decoder comprises four upsampling stages aimed at progressively restoring image resolution. The detailed architecture is illustrated in Figure 3. Stage 4 utilizes a 4× upsampling ratio, whereas the other stages employ 2× upsampling. The outputs of upsampling stages 1–3 are fused with feature maps 3-1 from the encoder via channel-wise concatenation, thus supplementing deep semantic features with shallow spatial details. To achieve model lightweighting, we apply 1 × 1 kernel depthwise separable convolutions subsequent to upsampling operations. This design significantly reduces the parameter count and computational overhead, while preserving feature representation capability. Lastly, upsampling stage 4 reconstructs the image to its original resolution and conducts pixel-wise semantic classification to accomplish the segmentation task.

3.2. GLF

To improve the detailed information extraction and enhance the feature extraction capability of the network, we introduce the Global–Local Feature (GLF) extraction module. The architecture of this module is depicted in Figure 4.

The GLF module integrates local–global information, multi-scale features, attention mechanisms, and channel shuffling. These strategies enhance feature diversity and the expressive capacity of feature extraction, enabling the module to address similar complex backgrounds in computer vision tasks and the limited feature extraction capabilities of networks. Consequently, the network training performance becomes more stable.

Specifically, the module processes input features through dual-branch extraction and aggregation. The local branch uses four dilated convolutions with different rates, while the global branch applies self-attention.

The input features (x) pass through four parallel dilated convolutions. We specifically adopt dilation rates [1–4] rather than alternatives like [1,3,5,7], as this progressive configuration ensures smoother multi-scale feature coverage. Furthermore, the smaller dilation rates inherently reduce padding operations and computational overhead, enhancing the module’s efficiency. We concatenate their outputs to form initial local features as follows:

$$x_1=Con{v}_1\left(x\right),x_2=Con{v}_2\left(x\right),x_3=Con{v}_3\left(x\right),x_4=Con{v}_4\left(x\right)$$

(1)

$$Local=Concat(x_1,x_2,x_3,x_4)$$

(2)

Subsequently, a channel shuffle operation blends features from different convolutional layers, enhancing inter-channel information flow. A 1 × 1 convolutional layer then transforms the mixed features to match input dimensions, producing the final local feature output as follows:

$$Loca{l}_f=Con{v}_f\left(ChannelShuffle\left(Local\right)\right)$$

(3)

The global branch applies self-attention to capture global features. This mechanism establishes global weighting through spatial positions that dynamically adjust attention weights across all locations, significantly enhancing contextual awareness. Initially, the branch flattens the input to obtain Query (Q), and extracts the Key (K) and Value (V) tensors through pyramid pool operations. The implementation steps are as follows:

$$Q=Flatten\left(x\right)$$

(4)

In the pyramid pool, we choose to use four maximum pools with strides of 2, 3, 5, and 6. The pooled results are concatenated after flattening to obtain P. P contains a large amount of global information. Therefore, we use channel shuffle and point convolution to enhance the information interaction across groups and obtain K and V. In our design, K and V are equal.

$$P_1=Maxpoo{l}_{2x2}\left(x\right),P_2=Maxpoo{l}_{3x3}\left(x\right),P_3=Maxpoo{l}_{5x5}\left(x\right),P_4=Maxpoo{l}_{6x6}\left(x\right),$$

(5)

$$P=Concat(P_1,P_2,P_3,P_4)$$

(6)

$$K=V=Con{v}_f\left(ChannelShuffle\left(P\right)\right)$$

(7)

After obtaining the attention parameters, we calculate the attention feature map. As shown in Equation (8), we compute the Q-K dot product and scale it by ${\displaystyle \frac{1}{\sqrt{c}}}$ (where c represents the feature dimension) to ensure numerical stability and mitigate gradient issues. Equation (8) applies softmax along the sequence dimension to convert attention scores into probability distributions. These weights then generate aggregated global context through weighted summation of the Value (V) tensor, as shown in (9). Finally, a convolutional linear transformation adjusts feature dimensions, producing refined global features in (10).

$$Att=softmax({\displaystyle \frac{1}{\sqrt{c}}}·(Q·K^T),dim=-1)$$

(8)

$$Globa{l}_f=Con{v}_f(Att·V)$$

(9)

$$Output=Loca{l}_f+Globa{l}_f$$

(10)

Equation (10) represents the output of the Global–Local Fusion (GLF) model. The features from both branches are combined through element-wise addition to produce the final feature extraction output. This fusion integrates detailed spatial information from local features with global contextual semantics, producing a robust feature map optimized for segmentation tasks.

3.3. GA

In semantic segmentation models, skip connections preserve spatial details between the encoder and decoder, reducing information loss from downsampling and improving boundary localization. However, direct addition-based connections often propagate excessive low-level textures and noise, hindering effective feature discrimination.

To overcome these limitations, we propose the Gated Attention (GA) module, which aims to address the issues associated with direct skip connections. The structure of the GA module is illustrated in Figure 5. The process of the GA module is divided into two parts: convolutional attention and gating. The convolutional attention implemented in this paper realizes multi-head attention through convolution operations. The specific implementation is as follows:

$$x=LayerNorm\left(x\right)$$

(11)

After the input is normalized, the number of channels is expanded to three times through dot convolution. At this point, it is equivalent to concatenating Q, K, and V into a tensor.

$$qkv=Conv\left(x\right)$$

(12)

Then, local feature extraction is carried out through depth-separable convolution, and the output tensor is segmented into attention parameters Q, K, and V through the chunk operation.

$$Q,K,V=Split\left(DWConv\right(qkv),dim=1)$$

(13)

Subsequently, the multi-head attention mechanism is applied to adjust the dimensions of the entire Q, K, and V from [B, dim, H, W] to [B, 4, dim/4, H*W]. After independently calculating the attention for each head and merging the results of multiple heads, the total attention output is obtained, and the feature channel is adjusted through point convolution.

$$Attention=softmax({\displaystyle \frac{1}{\sqrt{c}}}·(Q·K^T),dim=-1)·V$$

(14)

$$Attention=Conv\left(Attention\right)$$

(15)

Finally, the original input is added to the attention output through residual connection.

$$x_{att}=x+Attention$$

(16)

After the attention operation, we use a GLU (Gated Linear Unit) [34] for gating. This process is as follows:

$$x_1,x_2=Linear\left(Split\left(x\right)\right)$$

(17)

$$Gate=GeLU\left(DWCon{v}_1\left(x_1\right)\right)·DWCon{v}_2\left(x_2\right)$$

(18)

We assigned two branches, linearly transformed the original input, and divided it into two branches, as shown in Equation (18). The first branch only has convolution operations to extract features, while the second branch adds a Gelu at the end as an activation function to generate gated weights. Then, we multiply the results of the two branches to achieve gating.

$$Output=x_{att}+Gate\left(x_{att}\right)$$

(19)

The output of the GA model is shown in Equation (19). The GA module enhances the expressive power of low-level features by aggregating multiple enhancement results, reducing redundancy while preserving critical details.

3.4. GFANet

The lightweight backbone guarantees exceptionally high baseline inference speeds for the model. The integration of the GLF (Global–Local Feature) and GA (Gated Attention) modules results in a slight decrease in inference efficiency compared to the original backbone, but significantly enhances segmentation accuracy. This design allows GFANet to maintain competitive inference speeds while achieving high-precision performance, thereby achieving an optimal balance between computational efficiency and segmentation quality.

As illustrated in Figure 6, the complete GFANet architecture is realized by strategically integrating the GLF and GA modules into appropriate positions within the backbone network. GFANet’s primary objective is to achieve segmentation accuracy comparable to advanced semantic segmentation networks while significantly reducing memory usage and execution time.

4. Experiment

Comparative experiments were conducted between GFANet and representative semantic segmentation architectures. Three benchmark datasets widely used in water body segmentation were employed to evaluate GFANet’s performance against state-of-the-art approaches.

4.1. Experiment Configuration

Experiments were conducted on a Windows 10 OS with an Intel Core i5-12400 CPU (2.5 GHz, 32 GB RAM) and an NVIDIA GeForce RTX 2080 Ti GPU (11 GB VRAM). The deep learning framework comprised PyTorch 2.2.2 (Python 3.11.9), CUDA 12.1, and cuDNN 8.8.

To ensure fair comparison across experiments, we standardized the input resolution at 512 × 512 and trained models for 150 epochs to ensure full convergence. To accommodate the GPU memory constraints of large models, we set the batch size to 8, balancing memory limits and preventing overfitting from smaller batches. We employed the Adam optimizer with default settings, as its adaptive learning rate is widely adopted in segmentation tasks. Following Leslie N. Smith’s methodology [35], we conducted learning rate sensitivity tests on GFANet, as shown in Figure 7, ultimately selecting 1 × 10⁻³ from the optimal range as the initial rate, with a minimum value of 1 × 10⁻⁴ (0.1 × initial rate). And we implemented a cosine annealing schedule throughout the training process.

We used scaling, flipping, translation, and color transformation as data augmentation techniques to enrich the dataset. Using data augmentation, we dynamically expanded the dataset to four times its original size during training. This augmented data exist only within the training phase, thus being applied exclusively to the training set.

4.2. Evaluation Metrics

This study employs seven evaluation metrics: mean Intersection over Union (mIoU), mean Pixel Accuracy (mPA), Accuracy, F1-score, GigaFLOPS (GFLOPs), parameter count (Params), and frames per second (FPS). Among these, mIoU quantifies segmentation region accuracy, while mPA measures the proportion of correctly classified pixels. Accuracy provides the overall pixel-wise classification correctness, and F1-score balances precision and recall to handle class imbalance. Both metrics quantify segmentation performance. GFLOPs quantify computational complexity, reflecting GPU computational efficiency. Params quantify model complexity by parameter count, indicating memory footprint. FPS quantifies real-time performance by measuring video stream processing rate. The mIoU, mPA, Accuracy, and F1-score are calculated as follows:

$$mIoU={\displaystyle \frac{1}{N}}\sum _{i=1}^N{\displaystyle \frac{TP}{TP+FP+FN}}$$

(20)

$$mPA={\displaystyle \frac{1}{N}}\sum _{i=1}^N{\displaystyle \frac{T{P}_i+T{N}_i}{T{P}_i+T{N}_i+F{P}_i+F{N}_i}}$$

(21)

$$Accuracy={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}$$

(22)

$$F1={\displaystyle \frac{2·TP}{2·TP+FP+FN}}$$

(23)

where TP (True Positive) represents the count of pixels accurately predicted as positive. TN (True Negative) signifies the count of pixels accurately predicted as negative. FP (False Positive) indicates the count of pixels incorrectly predicted as positive. FN (False Negative) indicates the number of pixels that are incorrectly predicted to be negative. N is the number of categories.

4.3. Ablation Studies of GFANet

We conducted an ablation study on GFANet to validate the effectiveness of our design. The model was trained and evaluated on the RIWA dataset, with the quantitative results demonstrating the contributions of each module as shown in

Table 1. The ablation results of GFANet.

Methods	mIou	mPA	Accuracy	F1-Score	Params	GFLOPs
Backbone	76.97	85.39	87.54	81.7	1.95	2.23
Backbone + GLF	80.17	88.78	90.83	85.9	3.71	5.76
Backbone + GA	79.08	87.94	89.46	85.5	2.65	3.49
Backbone + GLF + GA	82.59	90.05	92.29	87.1	4.41	7.15

.

The results validate the feasibility and effectiveness of our design. Compared to the backbone network, integrating the GLF module yields improvements of +3.2% for mIoU, +3.39% for mPA/Accuracy, and +4.2 for F1-score. These enhancements stem from GLF’s dual-branch multi-scale feature extraction, which significantly strengthens the model’s representational capacity—albeit with increased parameters and computations.

Furthermore, optimizing low-level feature expression through refined skip connections also boosts performance. The standalone GA module surpasses the backbone by +2.17% for mIoU, +2.55% for mPA, +1.92% for Accuracy, and +3.8 for F1-score, while adding 0.7M for params and 1.23 for GFLOPs.

Crucially, the coordinated application of GLF and GA demonstrates synergistic effects, achieving compounded performance gains that confirm the modules’ complementary design principles.

4.4. Experiments of Lightweighting Comparison

To evaluate the performance of the proposed network, we compared it with various architectures, including UNet [13], DeeplabV3+ [15] (backbone = Xception), PSPNet [14] (backbone = ResNet50), and SegNet [36], which are large-scale CNNs. Along with LEDNet [37], SeaFormer [38], and LETNet [39], they are lightweight CNN.

To analyze the data clearly and straightforwardly, we made a separate comparison of the part of the model’s computational load in this section. After that, the comparison of the model’s reasoning ability will no longer show the data of computational load. The results of testing the sizes of each model using test images with a resolution of 512 × 512 are shown in

Table 2. Results of each model’s parameter size and inference speed.

Methods	Params	GFLOPs	FPS
UNet	24.89	225.83	33.16
DeeplabV3+	54.71	83.42	38.41
SegNet	29.44	160.67	40.88
PSPNet	46.71	184.73	32.49
LEDNet	0.91	5.71	157.01
SeaFormer	4.01	11.53	96.74
LETNet	0.94	7.83	125.63
GFANet (ours)	4.41	7.15	154.98

.

According to Table 2, GFANet maintains parameters of 4.41 for Params, 7.15 for gflops, and approximately 155 for FPS, which is significantly lighter than large-scale CNNS. Compared with other lightweight models, the parameter number of GFANet is approximately 3.5 M higher than that of LEDNet and LETNet, and 0.4 M higher than that of SeaFormer. However, in terms of computational complexity, the computational complexity of GFANet is only higher than that of LEDNet and lower than that of SeaFormer and LETNet, which indicates that the complexity within our network is relatively lower. Meanwhile, the real-time inference speed of GFANet is very fast. Under the same conditions, its inference speed is almost the same as that of the fastest LEDNet. Although SeaFormer and LETNet are also significantly faster than large-scale networks, there is a significant gap in speed compared with GFANet.

4.5. Experiments Based on the Riwa Dataset

The RIWA dataset was proposed by Wagner et al. [40] for evaluating water body segmentation networks. Comprising 1128 high-resolution water body images, RIWA establishes itself as one of the largest publicly available datasets for water body segmentation and can be obtained from https://www.kaggle.com/datasets/franzwagner/river-water-segmentation-dataset (accessed on 3 March 2025).

All datasets were partitioned into training, validation, and test sets with a fixed ratio of 7:1:2. To ensure fairness, no pre-trained weights were used across all models. Comparative results, including evaluation metrics and model parameters, are presented in

Table 3. The results of each model based on the Riwa dataset.

Methods	mIoU	mPA	Accuracy	F1-Score
UNet	81.66	88.75	91.61	86.1
DeeplabV3+	81.74	89.12	91.73	86.5
SegNet	82.86	90.46	92.73	87.2
PSPNet	81.06	88.97	91.71	85.8
LEDNet	78.98	87.61	89.03	85.7
SeaFormer	82.04	89.46	92.04	86.7
LETNet	81.43	88.97	91.62	86.2
GFANet (ours)	82.59	90.05	92.29	87.3

. GFANet outperforms all baseline architectures across the evaluated metrics. GFANet attains an mIoU of 82.59% and an mPA of 90.05%, outperforming all baselines, with the exception of SegNet (an mIoU of −0.27%, an mPA of −0.41%)—indicating minimal accuracy gaps. GFANet exhibits a 0.44% lower accuracy than SegNet, whereas its F1-score is 0.1 points higher. This suggests that while GFANet demonstrates superior recognition capability under class imbalance conditions, it shows marginally reduced detection precision for medium-sized objects compared to SegNet. Detailed results are provided in Table 3.

The segmentation results of representative architectures are visualized in Figure 8 with misclassified pixels: green (false water) and blue (false background). GFANet achieves performance comparable to top-performing SegNet while outperforming other architectures, exhibiting superior edge delineation precision. The original image accentuates this difference: all architectures, except for GFANet and SegNet, exhibit significant errors at riverbank edges. The lightweight model SeaFormer, which also has excellent data, performs poorly in actual operation. While SegNet misclassifies a small bottom-right water region as the background, GFANet accurately segments the entire water area.

Although GFANet exhibits marginally inferior edge discrimination performance compared to SegNet, the discrepancy is negligible. GFANet attains nearly fourfold faster inference speed than SegNet, alongside significantly reduced computational complexity and parameter count. This highlights GFANet as a balanced architecture, achieving a favorable trade-off between minimal accuracy reduction and substantial inference speed gains.

4.6. Experiments Based on the WaterSeg Dataset

The WaterSeg dataset was proposed by Liang et al. [41] for water segmentation in videos and images within Video Object Segmentation (VOS) research. By adopting the DAVIS dataset format, it has gained widespread adoption. The dataset can be downloaded from https://www.kaggle.com/datasets/gvclsu/water-segmentation-dataset (accessed on 11 March 2025).

GFANet maintains superior performance on the WaterSeg dataset (

Table 4. The results of each model based on the WaterSeg dataset.

Methods	mIoU	mPA	Accuracy	F1-Score
UNet	87.86	92.94	94.72	91.5
DeeplabV3+	87.24	92.13	94.41	90.4
SegNet	87.33	92.42	94.47	90.6
PSPNet	88.96	94.03	95.39	92.4
LEDNet	85.78	91.82	93.89	89.9
SeaFormer	88.53	93.91	95.31	92.3
LETNet	87.76	92.85	94.63	91.3
GFANet (ours)	88.49	93.68	95.16	92.1

), achieving an mIoU of 88.49% and an mPA of 93.68%, which is marginally lower than PSPNet (<0.5%) and SeaFormer (0.04% mIou and 0.23% mPA), significantly outperforming other architectures. The performance in terms of accuracy and f1-scores is the same.

The visualization results on the dataset are presented in Figure 9. Under low-light conditions, all architectures exhibit significant edge detection performance degradation.

Under these scenarios, SegNet—previously the top performer—exhibits accuracy degradation, while PSPNet achieves the highest segmentation precision. GFANet maintains competitive performance, exhibiting comparable overall error to PSPNet. GFANet retains significant advantages in inference speed and model complexity over other architectures.

4.7. Experiments Based on the USVInland Dataset

The USVInland dataset [42], developed and released by Orca-Tech researchers, focuses on inland waterway scenarios.

The quantitative results of architectures on the USVInland dataset are presented in

Table 5. The results of each model based on the USVInland dataset.

Methods	mIoU	mPA	Accuracy	F1-Score
UNet	93.96	97.07	96.91	97.5
DeeplabV3+	94.83	96.92	96.87	97.5
SegNet	96.13	98.05	98.05	98.1
PSPNet	96.27	98.18	98.17	98.2
LEDNet	94.31	97.21	97.16	97.4
SeaFormer	96.18	98.06	98.07	98.2
LETNet	95.86	97.63	97.74	97.8
GFANet(Ours)	96.25	98.14	98.12	98.1

. All architectures achieve higher accuracy on USVInland, attributed to the dataset’s simpler image characteristics compared to other benchmarks. Under these conditions, the performance differences between architectures are reduced. GFANet was slightly lower than PSPNet (<0.05%) in the first three indicators and slightly higher than SeaFormer (<0.1%). In terms of f1-score, GFANet achieved a score of 98.1, while PSPNet and SeaFormer achieved 98.2. This indicates that in this dataset, both of them have stronger detail capabilities.

We chose pictures of rain interference to increase the differences. The results are visualized in Figure 10. Except for GFANet, PSPNet, and SeaFormer, the other models all have large segmentation errors in the left bank area. In terms of the remote details, SeaFormer demonstrated the best performance (which is in line with the data results).

Experiments on three datasets (Riwa, WaterSeg, USVInland) encompassed images under diverse lighting conditions: bright, dim, and partially occluded scenarios. The results reveal that GFANet exhibits superior performance in high-brightness environments and reduced performance in low-light conditions. Nevertheless, GFANet consistently delivers more precise water area and boundary segmentation than competing architectures across diverse environments. This highlights GFANet’s superior transferability and enhanced robustness, enabling effective adaptation to diverse environmental conditions in water segmentation. Collectively, GFANet is ideally suited for real-world water surface semantic segmentation applications.

5. Conclusions

This study introduces GFANet (Global–Local Feature Attention Network), a real-time water surface semantic segmentation architecture leveraging Local–Global Feature extraction and gated attention mechanisms. Comprehensive experiments were performed on three benchmark datasets: RIWA, WaterSeg, and USVInland. Evaluation was assessed across four dimensions: segmentation accuracy, computational complexity, model size (parameters), and inference speed. The experimental results (as detailed in Table 3 and Figure 7) reveal that GFANet achieves a favorable balance between segmentation precision and computational efficiency, maintaining high accuracy with significantly reduced parameters and computational complexity compared to conventional CNN architectures.

While this study simulated three common real-world environmental scenarios (bright, low-light, and rain-interfered conditions), practical deployment tests on unmanned surface vehicles (USVs) or surveillance devices were not included.

Future research will focus on deploying GFANet on unmanned surface vehicles (USVs) to address real-world operational challenges. This entails the systematic exploration of (1) hardware–software co-design for embedded implementation, (2) computational graph optimization for resource-constrained edge devices, and (3) dynamic video stream analysis with multisensor fusion extensions. These efforts aim to (1) resolve deployment-specific bottlenecks, (2) expand application scenarios in marine environmental monitoring and intelligent navigation systems, and (3) validate GFANet’s practical utility in real-world contexts.