The Lightweight Fracture Segmentation Algorithm for Logging Images Based on Fully 3D Attention Mechanism and Deformable Convolution

Abstract

The challenge of fracture segmentation remains a significant obstacle in imaging logging interpretation within the current oil and gas exploration and development field. However, existing image segmentation algorithms still encounter issues related to accuracy, speed, and robustness, as well as a tendency to misdetect or overlook small fractures when applied to logging image fracture segmentation tasks. To address these challenges comprehensively, this paper proposes an end-to-end fracture segmentation algorithm named SWSDS-Net. This algorithm is built upon the UNet architecture and incorporates the SimAM with slicing (SWS) attention mechanism along with the deformable strip convolution (DSCN) module. The SWS introduces a fully 3D attention mechanism that effectively learns the weights of each neuron in the feature map, enabling better capture of fracture features while ensuring fair attention and enhancement for both large and small objects. Additionally, the deformable properties of DSCN allow for adaptive sampling based on fracture shapes, effectively tackling challenges posed by varying fracture shapes and enhancing segmentation robustness. Experimental results demonstrate that SWSDS-Net achieves optimal performance across all evaluation metrics in this task, delivering superior visual results in fracture segmentation while successfully overcoming limitations present in existing algorithms such as complex shapes, noise interference, and low-quality images. Moreover, serving as a lightweight network solution enables SWSDS-Net’s deployment on mobile devices at remote sites—an advancement that lays a solid foundation for interpreting logging data and promotes deep learning technology application within traditional industrial scenarios.

1. Introduction

Logging technology plays a pivotal role in the field of oil and gas exploration and development by unveiling lithological characteristics, as well as the distribution and structure of fractures surrounding the wellbore. Fractures, being micro-geological structures, exert a significant influence on the distribution and seepage properties of oil, gas, and water. Consequently, they provide invaluable insights for oil and gas field exploration and development activities. In recent years, semantic segmentation has emerged as a prominent topic in computer vision research, with widespread application in fracture segmentation within logging images. Among various approaches used for this purpose, the UNet network stands out as the most commonly employed method. However, existing fracture segmentation methods possess certain limitations that need to be addressed. The current challenges revolve around designing a more lightweight version of the UNet network suitable for mobile devices and on-site deployment while also developing more efficient variants to enhance accuracy, speed, robustness, and interpretability in fracture segmentation.

With the rapid advancement of deep learning technology, segmentation methods based on deep learning have demonstrated significant potential in fracture segmentation tasks. Among these methods, the UNet architecture has gained widespread application due to its simplicity, ease of implementation, and excellent segmentation performance. Originally proposed by Ronneberger et al. (2015) [1], the UNet architecture employs an encoder–decoder structure that effectively separates the feature extraction and decoding processes of images. By incorporating skip connections, it successfully integrates low-level and high-level features to achieve pixel-level segmentation [2].

In recent years, UNet has been widely utilized for fracture segmentation tasks in imaging logging [3] and has achieved remarkable outcomes. Researchers commonly combine UNet with various feature extraction modules and loss functions to enhance segmentation accuracy and robustness. Feature extraction modules, such as ResNet [4], VGG [5], and EfficientNet [6], are employed to extract more comprehensive image features. Loss functions like Dice Loss [7], Jaccard Loss [8], and Focal Loss [9] are applied to improve segmentation precision. Fatimah Alzubaid et al. (2022) [10] proposed a fracture detection and characterization method based on Mask R-CNN that achieves a 95% accuracy rate in identifying and analyzing fractures from unwrapped core images. Nevertheless, this method may not fully encompass the complexity and diversity of authentic fractures. Luciana Olivia Dias et al. (2020) [11] proposed a novel method for automatic detection of fractures and breakout patterns in acoustic borehole image logs using fast-region convolutional neural networks (fast-RCNNs). In real images, a fast-RCNN can also effectively detect fractures and parts of breakouts. However, the method has limitations in detecting real breakouts, such as failing to recognize a pair of breakouts as a single event. Chao Li et al. (2024) [12] proposed a deep learning method based on transfer learning for intelligent identification and segmentation of fractures in ultrasonic logging images. Hongda Yu et al. (2024) [13] proposed a deep learning-based method for fracture identification from logging images, effectively overcoming the limitations of low efficiency in manual detection and poor accuracy of previous automated methods. Bing Xiong et al. (2024) [14] proposed a U-shaped network architecture known as the fusion–channel–Transformer network (FCT-Net), which comprises the channel atrous spatial pyramid pooling (CASPP) module, Transformer module, and attention weight cross fusion (AWCF) module. This network integrates local and global context features through a dual-branch encoding structure that effectively extracts multi-scale information from fracture images while progressively recovering image details during the decoding process. However, Transformer models generally require significant computational resources, limiting their real-time fracture detection capabilities and posing challenges for deployment on portable devices. Furthermore, Bing Xiong et al. (2024) [15] introduced a multi-scale dual-encoding fusion network (DefNet) based on the UNet architecture that extracts global and local features of fracture images using the stacked convolutional distillation module (CDM) and dual-branch attention Transformer (DBAT) modules. They also introduced a multi-scale information distillation mechanism and a large separable kernel attention (LSKA) module to construct the CDM encoder, surpassing the limitations of the traditional convolutional neural network (CNN) receptive field. Jianming Zhang et al. (2024) [16] proposed a dual-encoder crack segmentation network (DECS-Net), which combines the advantages of CNN and Transformer to address the issue of complex background interference in fracture segmentation. DECS-Net utilizes a high–low-frequency attention mechanism and a locally enhanced feedforward network to extract local and global features from images, respectively, subsequently fusing them through a feature fusion module and effectively enhancing the accuracy and recall rate of crack segmentation. Jia Liang et al. (2024) [17] proposed an innovative CNN-based pavement crack segmentation network (CSNet), integrating multi-scale context features with an attention mechanism for improved detection accuracy. CSNet demonstrates exceptional performance on various datasets, outperforming other segmentation models. However, it still faces challenges in micro-crack detection as well as requiring substantial labeled data for training purposes. Despite these advancements, there is still room for improvement when dealing with low-quality imaging, significant noise interference, and complex shapes in logging images. Additionally, there are significant challenges remaining regarding segmentation speed, model lightweighting, and interpretability.

In summary, this paper integrates SimAM with slicing (SWS) attention [18] and deformable strip convolution (DSCN) [19] into the UNet architecture, effectively enhancing the model’s performance in fracture segmentation tasks for imaging logging. Traditional UNet attention mechanisms primarily focus on channel and spatial dimensions. However, SWS introduces a fully 3D attention mechanism that more accurately learns the weights of each neuron in the feature map, thereby capturing fracture features with greater precision. Additionally, we have introduced a slicing operation to ensure equitable attention and enhancement for both large and small objects. Through SWS, the model can better concentrate on key regions of fractures while suppressing background noise, thus improving segmentation accuracy. Furthermore, the original UNet convolution has a fixed receptive field, which limits its adaptability to diverse fracture shapes. DSCN possesses deformable properties that enable adaptive sampling based on fracture shapes, resulting in more effective extraction of fracture features and addressing challenges posed by varying fracture shapes while enhancing segmentation robustness. By utilizing the improved UNet model, fractures in imaging logging can be segmented more accurately, providing reliable data for oil and gas exploration and development. This promotes the application of deep learning technology in industrial fields while serving as a reference for other domains.

2. Theoretical Foundations

2.1. SWSDS-Net Network Architecture

The UNet model effectively preserves multi-level feature information by utilizing skip connections and concatenating feature maps at different levels [20], thereby enhancing its representational capacity. Hence, for imaging logging fracture segmentation tasks with limited datasets and high costs involving single-class target semantic segmentation, employing UNet as a baseline model is a favorable solution. UNet comprises an encoder part and a decoder part. The encoder consists of multiple convolutional layers and pooling layers that progressively reduce the image’s spatial resolution while extracting features [21]. Typically, each convolutional layer is followed by a batch normalization layer and an activation function to augment the model’s learning capability. The final convolutional layer in the encoder generates a low-resolution feature map, which serves as input for the decoder. The decoder comprises multiple convolutional layers and upsampling layers that gradually restore the image’s spatial resolution while reconstructing features. Similar to the encoder, each convolutional layer in the decoder is usually accompanied by a batch normalization layer and an activation function to enhance learning ability. To guide feature reconstruction, each convolutional layer in the decoder is concatenated with its corresponding counterpart in the encoder through skip connections, effectively preserving multi-level feature information and improving segmentation accuracy. Finally, the last convolutional layer of the decoder produces a high-resolution feature map, which serves as the final segmentation result.

The network architecture, named SimAM with slicing deformable strip (SWSDS-Net), is constructed based on UNet. It incorporates SWS into both the encoder and the decoder, replacing the original convolution with DSCN. This integration effectively addresses the challenges posed by variations in fracture shapes, enhancing the model’s robustness in complex scenarios while reducing parameters and computational cost. Consequently, it accelerates the training process.

The overall architecture of SWSDS-Net, as depicted in the figure, adopts a symmetrical U-shaped structure. The left pathway is responsible for feature extraction and encoding, while the right pathway handles feature reconstruction and decoding. The left pathway comprises convolutional layers and pooling layers that progressively increase channel numbers and reduce feature map sizes to extract shallow target features. Conversely, the right pathway consists of convolutional layers and upsampling layers that gradually decrease channel numbers and enlarge feature map sizes to extract deep target features. Between these pathways, skip connections are employed to integrate shallow features from the left pathway with deep features from the right pathway, thereby achieving comprehensive recognition and segmentation of the target [22].

In the feature extraction process of the UNet network, redundant features, such as background noise [23], may be present. These features contribute minimally to the final segmentation task but significantly increase the computational burden of the model. Spatial weighted sum (SWS) effectively mitigates these redundant features by learning weights for each feature map, thereby enhancing feature extraction efficiency. Moreover, when processing objects with complex shapes in UNet, challenges like blurred edges or inaccurate shapes can arise. Dynamic shape convolutional networks (DSCNs), through learning offsets, adaptively adjust the receptive field of convolutional kernels to better suit irregularly shaped objects like fractures and enhance model adaptability to complex shapes. Furthermore, compared to traditional convolution operations, DSCNs have fewer parameters and lower computational costs, which effectively reduces computational burden while optimizing resource utilization. The incorporation of SWS and a DSCN also enhances depth in feature learning by facilitating a better fusion of shallow and deep features, ultimately leading to improved segmentation accuracy [24].

After preprocessing, the logging images are fed into the encoding section, which sequentially undergoes two convolutional layers and a pooling layer in a repetitive manner. This progressive process gradually increases the number of channels while reducing the size, resulting in an output feature size of $1024\times 16\times 16$. In the decoding section, through transposed convolution and concatenation operations, the channel count is initially doubled and subsequently reduced to ultimately generate a feature map with identical dimensions as the input image. In Figure 1, both the encoder’s and the decoder’s conventional convolutional layers are substituted with DSCN for enhanced performance, while SWS is incorporated after upsampling in both sections.

2.2. DSCN Principle and Design

The convolution operation in UNet is standardized, featuring a fixed receptive field that lacks adaptability to the shape variations of the target object. This inherent limitation hampers UNet’s effectiveness in extracting features from complex object shapes. Deformable convolutional networks v3 (DCNv3) introduces deformable convolution [25] operations that enhance adaptability to the target object’s shape. Moreover, DCNv3 employs a convolutional kernel with a global receptive field [26], enabling better capture of relationships between target objects. By learning sampling position offsets and modulation masks, the convolutional kernel can dynamically adjust to different shapes, thereby facilitating more effective feature extraction from the target object. However, when employing large kernel convolutions in DCNv3, there is a significant increase in computational cost—particularly during training—as it necessitates storing numerous offsets and modulation masks, resulting in high memory consumption and slower training speeds.

The paper thus proposes a simplification of DCNv3, resulting in the development of DSCN, a lightweight deformable convolution operation. The specific steps involved in this simplification process are as follows:

The computational cost of DCNv3 increases quadratically as the kernel size grows due to its sampling in both the horizontal and the vertical directions. For instance, a $3\times 3$ DCNv3 convolutional kernel necessitates 9 sampling points, while a $5\times 5$ DCNv3 convolutional kernel requires 25 sampling points.

Here, $△p_k$ represents the coordinate offset of the k-th sample point in the convolution kernel on the spatial domain, where $k$ is equivalent to $(i, j)$ when expressed in spatial coordinates. $G$ represents the quantity of deformable groups. Moreover, ${\mathsf{\Sigma }}_{g=1}^G$ represents the individual sampling founded on the learned offsets of each deformable group. ${\mathit{y}}^1\left(i_0, j_0\right)$ and ${\mathit{y}}^2\left(i_0, j_0\right)$, respectively, denote the values of the output feature map at position $\left(i_0, j_0\right)$ after conducting convolution operations along the $x$-axis and $y$-axis. $m_{0,j}^1$ and $m_{i,0}^2$ represent the weights of the modulation mask. ${\mathbf{w}}^1$ and ${\mathbf{w}}^2$ represent the weights of the linear mapping. $△p_j^g$ and $△p_i^g$, respectively, denote the offsets of the jth and ith sampling points of the gth deformable group.

$${\mathit{y}}^1\left(i_0, j_0\right)=\sum _{g=1}^G\sum _{j=0}^{K_w-1}{\mathbf{w}}^1{m}_{0,j}^1\mathbf{x}(i_0,j_0+j+△p_j^g)$$

(1)

$${\mathit{y}}^2\left(i_0, j_0\right)=\sum _{g=1}^G\sum _{i=0}^{K_h-1}{\mathbf{w}}^2{m}_{i,0}^2{\mathit{y}}^1(i_0+i+△p_i^g,j_0)$$

(2)

The final output is obtained by substituting Equation (1) with Equation (2), and then sampling the superpixels along the $x$-axis and $y$-axis, respectively. The $K_w$ and $K_h$ represent the sampling size on the $x$-axis and $y$-axis.

$${\mathit{y}}^2\left(i_0, j_0\right)=\sum _{g=1}^G\sum _{i=0}^{K_h-1}\sum _{j=0}^{K_w-1}{\mathbf{w}}^{\prime }{m}_{i,j}^{\prime }\mathbf{x}(i_0+i+△p_i^g,j_0+j+△p_i^g)$$

(3)

In Figure 2, The DSCN technique restricts the sampling to a single direction, such as the $x$-axis or $y$-axis, thereby enabling a $3\times 3$ DSCN convolutional kernel to utilize only three sampling points and a $5\times 5$ DSCN convolutional kernel to require just five sampling points. This approach of constraining the sampling direction effectively reduces the computational burden of DSCN, rendering it more suitable for lightweight CNN architectures.

$${\mathit{y}}^1\left(i_0, j_0\right)=\sum _{g=1}^G\sum _{j=0}^{K_w-1}\mathbf{w}\mathbf{x}(i_0,j_0+j+△p_j^g)$$

(4)

$${\mathit{y}}^2\left(i_0, j_0\right)=\sum _{g=1}^G\sum _{i=0}^{K_h-1}{\mathbf{y}}^1(i_0+i+△p_j^g, j_0)$$

(5)

Secondly, DCNv3 employs bilinear interpolation for sampling, which is a relatively intricate interpolation technique entailing high computational overhead. Bilinear interpolation necessitates two linear interpolations and one weighted summation operation. Assuming the presence of three spatial coordinates $(x_0,y_0)$, $(x_1, y_1)$, and $(x_2,y_2)$, $f(x_0,y_0)$ can be computed using the bilinear interpolation formula with $f(x_1, y_1)$ and $f(x_2,y_2)$.

$$\begin{array}{c}f\left(x_0,y_0\right)=f\left(x_1, y_1\right)\left(x_2-x_0\right)\left(y_2-y_0\right)\\ +f\left(x_1, y_2\right)\left(x_0-x_1\right)\left(y_2-y_0\right)\\ +f\left(x_1, y_2\right)\left(x_2-x_0\right)\left(y_0-y_1\right)\\ +f\left(x_2, y_2\right)\left(x_0-x_1\right)\left(y_0-y_1\right)\end{array}$$

(6)

The DSCN, in contrast, employs linear interpolation for sampling, which is a simpler interpolation method with reduced computational complexity. It only necessitates two linear interpolation operations.

$$f^{\prime }\left(x_0,y_1\right)=f\left(x_1, y_1\right)\left(x_0-x_1\right)+f\left(x_2, y_1\right)\left(x_2-x_1\right)$$

(7)

$$f\left(x_0,y_0\right)=f^{\prime }\left(x_0,y_1\right)\left(y_0-y_1\right)+f^{\prime }\left(x_1, y_2\right)\left(y_2-y_1\right)$$

(8)

The DCNv3 model employs a modulation mask to regulate the sampling weights, thereby increasing both the parameter count and the computational overhead. In contrast, DSCN eliminates the need for a modulation mask and instead utilizes a straightforward weight matrix to control the sampling weights, resulting in a significant reduction in complexity as well as a decreased parameter count and computational cost.

In summary, the input feature map undergoes a depthwise convolution (DWConv) initially to reduce dimensionality in the channel dimension. This is followed by a linear projection layer that generates offsets through a linear transformation. These offsets are utilized to control subsequent sampling positions, allowing the convolutional kernel to adaptively adjust the receptive field according to features of varying shapes and sizes. Subsequently, the input feature map is interpolated linearly based on these generated offsets using a linear function for estimating values between sampling points. The sampled feature map encompasses feature information surrounding the target object, thereby aiding in improved recognition and localization by the network. Finally, this sampled feature map passes through another DWConv operation to increase dimensionality in the channel dimension and restore its original number of channels within the feature map, ensuring effective connectivity with subsequent layers. Consequently, the output feature map contains DSCN-processed features specific to the target object.

2.3. SWS Principle and Design

Based on the simple attention mechanism (SimAM), we have introduced a slicing operation and proposed SWS, aiming to address the limitations of traditional attention mechanisms in small target segmentation in imaging logging. Unlike most existing attention modules, SimAM can infer 3D attention weights by simultaneously considering both channel and spatial dimensions, thereby enhancing the network’s feature representation capabilities while maintaining its lightweight nature without increasing the parameter count. Drawing inspiration from the spatial inhibition theory in neuroscience, which suggests that active neurons inhibit surrounding neuron activity to highlight important information, we calculate 3D attention weights through the following three steps [27]:

The SimAM algorithm first establishes an energy function to quantify the degree of linear separability between a single neuron and its neighboring neurons within the same channel. A lower energy value indicates a greater distinction between this particular neuron and its surrounding counterparts, thereby highlighting its significance in visual processing.

$$e_t\left(w_t, b_t, \mathit{y}, x_i\right)={\left(y_t-\widehat{t}\right)}^2+{\displaystyle \frac{1}{M-1}}{\sum _{i=1}^{M-1}(y_o-{\widehat{x}}_i)}^2$$

(9)

Here, $\widehat{t}=w_{t}t+b_t$ and ${\widehat{x}}_i=w_t{x}_i+b_t$ are linear transforms of $t$ and $x_i$, where $t$ and $x_i$ are the target neuron and other neurons in a single channel of the input feature $\mathbf{X}\in {\mathbb{R}}^{C\times H\times W}$. $i$ is index over spatial dimension.$M=H\times W$ is the number of neurons on that. $w_t$ and $b_t$ are the weight and bias of the transform.

The transformed variables $\widehat{t}=w_{t}t+b_t$ and ${\widehat{x}}_i=w_t{x}_i+b_t$ represent linear transformations of $t$ and $x_i$, respectively. Here, $i$ denotes the index and $M=H\times W$ represents the total number of neurons. The weight $w_t$ and bias $b_t$ are utilized for this transformation process. Upon simplification, we obtain the final energy function.

$$e_t\left(w_t, b_t, \mathit{y}, x_i\right)={\displaystyle \frac{1}{M-1}}{\sum _{i=1}^{M-1}(-1-(w_t{x}_i+b_t))}^2+{(1-(w_{t}t+b_t\left)\right)}^2+\lambda w_t^2$$

(10)

The next step involves deriving a closed-form solution for the energy function, which allows SimAM to efficiently calculate the significance of each neuron. Here, $\widehat{\mu }={\displaystyle \frac{1}{M}}{\sum }_{i=1}^M{x}_i$ and ${\widehat{\sigma }}^2={\displaystyle \frac{1}{M}}{\sum }_{i=1}^M{(x_i-\widehat{\mu })}^2$.

$${\mu }_t={\displaystyle \frac{1}{M-1}}{\sum }_{i=1}^{M-1}{x}_i$$

(11)

$${\sigma }_t^2={\displaystyle \frac{1}{M-1}}{\sum }_i^{M-1}{(x_i-{\mu }_t)}^2$$

(12)

$$w_t=-{\displaystyle \frac{2(t-{\mu }_t)}{{(t-{\mu }_t)}^2+2{\sigma }_t^2+2\lambda }}$$

(13)

$$b_t=-{\displaystyle \frac{1}{2}}(t+{\mu }_t)w_t$$

(14)

$$e_t^{*}={\displaystyle \frac{4({\widehat{\sigma }}^2+\lambda )}{{(t-\widehat{\mu })}^2+2{\widehat{\sigma }}^2+2\lambda }}$$

(15)

The $sigmoid$ function is employed to confine the value of the energy function $\mathbf{E}$ within the range of 0 and 1, thereby obtaining the weight of each neuron. Subsequently, the SimAM model ultimately leverages the significance of each individual neuron as its attention weight, enabling it to conduct element-wise multiplication with the feature map and thus attaining a weighted feature map.

$$\tilde{\mathbf{X}}=sigmoid\left({\displaystyle \frac{1}{\mathbf{E}}}\right)\odot \mathbf{X}$$

(16)

In Figure 3, The SimAM model employs a multi-head attention mechanism [28], facilitated by multi-layer stacking, to effectively capture long-range dependencies within the input sequence. By incorporating residual connections, the output of the multi-head attention layer is seamlessly integrated with the input sequence, ensuring preservation of all pertinent information. Furthermore, a normalization layer applies layer normalization to the feedforward layer’s output, thereby expediting training and enhancing model performance while facilitating learning and generation of the corresponding output sequence [29].

Building on this, the SWS module introduces a slicing operation that partitions the feature map into multiple non-overlapping blocks. This slicing operation enables the module to compute local statistics instead of global statistics, which is particularly advantageous for emphasizing small objects that may be overlooked within these blocks. Each block independently calculates its average pixel variation, effectively capturing the distinctiveness of small targets within that specific block. Small targets exhibiting deviations from the local average are assigned higher weights, thereby enhancing their features. Subsequently, after computing the weight for each block, the feature map is reassembled by applying these weights to ensure enhanced representation of small targets while maintaining or further amplifying features of larger targets as required.

3. Results and Discussion

3.1. Dataset and Experimental Setup

The dataset utilized in this study comprises 34 imaging logging images, each with dimensions of $280\times 280$. These images were annotated using Labelme, with two target classes: cracks and background. Corresponding JSON label files were generated and subsequently converted into the PNG format required for UNet training. Offline data augmentation techniques, such as rotation and scaling, were employed to augment the dataset size by a factor of 10, resulting in a total of 340 images. The final images were resized to dimensions of $256\times 256$ and underwent online data augmentation before being used for training.

The experimental hardware setup comprises a Windows 10 system equipped with an Intel(R) Xeon(R) CPU @ 20.20 GHz (6 cores) and an NVIDIA GeForce RTX 3060 GPU boasting 8 GB of memory. The software environment encompasses Python 3.10, PyTorch 2.0.1, and CUDA 11.8.

Considering the relatively limited size of the dataset utilized in this paper, it is crucial to obtain a more robust and reliable evaluation of model performance. Therefore, we have employed k-fold cross-validation with $k$ set to 7. The specific steps are as follows: Firstly, the entire dataset is divided into seven equally sized subsets. Subsequently, seven rounds of training and validation are conducted. In each round, the i-th subset serves as the validation set, while the remaining six subsets are combined to form the training set. The model undergoes training on this set and is then tested on the validation set, with performance metrics being recorded accordingly. Finally, an average of these performance metric results from all seven rounds $(S1~S7)$ is calculated to derive a comprehensive evaluation of the model’s performance [30].

3.2. Evaluation Metrics

The evaluation metrics employed in this paper encompass intersection over union (I), precision (P), recall (R), and the dice coefficient (D). True positive (TP) denotes the accurate prediction of positive samples as positive, false positive (FP) signifies the erroneous prediction of negative samples as positive, and false negative (FN) indicates the incorrect prediction of positive samples as negative [31].

$$I={\displaystyle \frac{T_{\mathrm{P}}}{T_{\mathrm{P}}+F_{\mathrm{P}}+F_{\mathrm{N}}}}$$

(17)

$$P={\displaystyle \frac{T_{\mathrm{P}}}{T_{\mathrm{P}}+F_{\mathrm{P}}}}$$

(18)

$$R={\displaystyle \frac{T_{\mathrm{P}}}{T_{\mathrm{P}}+F_{\mathrm{N}}}}$$

(19)

$$D={\displaystyle \frac{2T_{\mathrm{P}}}{2T_{\mathrm{P}}+F_{\mathrm{P}}+F_{\mathrm{N}}}}$$

(20)

3.3. Attention Module Comparison Experiments

In the comparative experiments, various attention mechanisms were incorporated into the UNet baseline model. SE [32] employs 1D attention weights, Coordinate and CBAM employ 2D attention weights [33], and Biformer [34] employs 3D attention weights. Comparatively speaking, the Coordinate structure is more intricate, as it necessitates constructing an attention module and integrating it into the network, along with introducing additional parameters such as convolutional kernels and fully connected layers. Similar to Coordinate, both SE and CBAM introduce extra parameters and possess relatively complex structures. Although Biformer can capture more intricate feature interactions through self-attention mechanisms, it requires a substantial number of parameters, has a complex structure, and incurs high computational costs. Overall, SWS does not introduce additional parameters but still achieves comparable performance in terms of inference speed and accuracy to other attention mechanisms [35].

In

Table 1. Comparisons of different attention performance.

Model	P	R	D	Params
Base	68.4	51.0	58.4	$-$
SWS	70.8	53.4	60.9	+460 K
Coordinate	69.9	51.7	59.4	+560 K
SE	69.3	51.9	59.3	+590 K
CBAM	68.2	51.6	58.7	+590 K
Biformer	65.0	48.3	55.4	+4.67 M

, The UNet baseline model, serving as the baseline, has a P of 68.4%, an R of 51.0%, and a D of 58.4%. SE and CBAM offer comparable performance, with the P for both being approximately 69.3%, R being approximately 51.6%, and D being approximately 59.0%. The increase in their parameters is approximately 590 K. In contrast to the original model, they augment more parameters, yet the improvement in accuracy is rather limited. For the current task, they are not favorable choices. Biformer has a P of 65.0%, an R of 48.3%, and a D of merely 55.4%. Nevertheless, it possesses the largest number of parameters, increasing by 4.67 M. Comparatively speaking, Biformer is the least effective, introducing the greatest number of parameters but experiencing a notable decline in accuracy. Therefore, Biformer is the poorest choice. Coordinate achieves a P of 69.9%. The recall rate is similar to that of the baseline model, and D improves to 59.4%. The increase in parameters is 560 K. Among all the attention modules, the increase in parameters of Biformer is the second smallest, but the accuracy improves significantly. The P and R reach 70.8% and 53.4% respectively, and D increases to 60.9%. On the whole, SWS proves to be an outstanding choice for this task.

3.4. Model Comparison Experiments

The effectiveness of the proposed SWSDS-Net for imaging logging fracture segmentation was verified through comparison experiments conducted with four well-established models, namely, UNet, UNetPlus, UNet++, and 3D-UNet, all under identical conditions.

In

Table 2. Test results of each model.

Parameter	Model	S1	S2	S3	S4	S5	S6	S7	Average
P	UNet	0.741	0.660	0.635	0.763	0.732	0.685	0.645	0.694
	3D-UNet	0.710	0.535	0.687	0.734	0.617	0.617	0.544	0.636
	UNetPlus	0.674	0.690	0.561	0.681	0.509	0.667	0.599	0.639
	UNet++	0.718	0.716	0.655	0.756	0.545	0.635	0.628	0.664
	SWSDS-Net	0.789	0.775	0.702	0.811	0.564	0.692	0.647	0.712
R	UNet	0.387	0.667	0.653	0.391	0.495	0.577	0.403	0.510
	3D-UNet	0.453	0.613	0.593	0.512	0.599	0.675	0.538	0.570
	UNetPlus	0.210	0.471	0.535	0.095	0.497	0.356	0.178	0.334
	UNet++	0.521	0.662	0.702	0.552	0.703	0.727	0.678	0.653
	SWSDS-Net	0.534	0.642	0.701	0.512	0.658	0.714	0.503	0.608
I	UNet	0.615	0.705	0.682	0.644	0.670	0.693	0.634	0.663
	3D-UNet	0.636	0.650	0.687	0.681	0.684	0.703	0.652	0.670
	UNetPlus	0.530	0.647	0.633	0.503	0.626	0.618	0.537	0.584
	UNet++	0.645	0.710	0.694	0.663	0.633	0.717	0.643	0.672
	SWSDS-Net	0.675	0.696	0.692	0.661	0.667	0.707	0.640	0.676
D	UNet	0.509	0.664	0.644	0.517	0.591	0.626	0.496	0.578
	3D-UNet	0.553	0.571	0.637	0.603	0.608	0.645	0.541	0.594
	UNetPlus	0.320	0.599	0.548	0.167	0.503	0.464	0.274	0.411
	UNet++	0.604	0.688	0.678	0.638	0.614	0.678	0.652	0.650
	SWSDS-Net	0.637	0.702	0.702	0.628	0.607	0.703	0.566	0.649

, in terms of P, the average value of the UNet baseline model is 0.694, that of 3D-UNet is 0.636, that of UNetPlus is 0.639, that of UNet++ is 0.664, and that of SWSDS-Net is 0.712. SWSDS-Net demonstrates the best performance in P, followed by UNet, UNet++, UNetPlus, and 3D-UNet. Regarding R, the average value of the UNet baseline model is 0.510, that of 3D-UNet is 0.570, that of UNetPlus is 0.334, that of UNet++ is 0.653, and that of SWSDS-Net is 0.608. SWSDS-Net demonstrates the best performance in R, followed by UNet++, 3D-UNet, UNet, and UNetPlus. Concerning I, the average value of the UNet baseline model is 0.663, that of 3D-UNet is 0.670, that of UNetPlus is 0.584, that of UNet++ is 0.672, and that of SWSDS-Net is 0.676. SWSDS-Net also demonstrates the best performance in I, followed by UNet++, 3D-UNet, UNet, and UNetPlus. Finally, with respect to D, the average value of the UNet baseline model is 0.578, that of 3D-UNet is 0.594, that of UNetPlus is 0.411, that of UNet++ is 0.650, and that of SWSDS-Net is 0.649. SWSDS-Net again demonstrates the best performance in D, followed by UNet++, 3D-UNet, UNet, and UNetPlus. Overall, SWSDS-Net exhibits the optimal performance in all parameters of the evaluation metrics.

The experimental results demonstrate that UNet++ outperforms other models in terms of P, R, I, and D. However, due to its complex network structure, large number of parameters, and high computational cost, it is not suitable for on-site deployment on mobile devices for imaging logging fracture segmentation. In contrast, the proposed SWSDS-Net achieves high accuracy while being lightweight without introducing additional parameters or significantly increasing computational costs. It effectively improves small target detection accuracy. Although 3D-UNet has the capability to handle 3D data and capture 3D features, it does not perform well in this specific scenario. UNetPlus reduces the number of channels to enhance model efficiency but sacrifices some accuracy.

In summary, SWSDS-Net effectively enhances the performance of fracture segmentation tasks in imaging logging by introducing the SWS and DSCN modules. These modules establish a closed loop between the encoder and decoder of UNet, where the feature maps from the encoder undergo upsampling and are concatenated with the feature maps from the decoder. Subsequently, the SWS module is reintegrated into the encoder to further enhance its representational capacity. This design effectively exploits SWS’s fully 3D attention mechanism, thereby improving segmentation accuracy. The figures depicting segmentation results demonstrate that SWSDS-Net yields minimal noise and interference in segmented targets. Through objective network performance comparisons, segmentation result analysis, and subjective visual evaluation, SWSDS-Net’s effectiveness is convincingly demonstrated.

In Figure 4, after analyzing the segmentation results, it is evident that all of these networks perform admirably when dealing with simpler scenes characterized by minimal noise and interference. However, in more intricate scenarios, UNetPlus exhibits a higher susceptibility to noise interference, resulting in notable false positives and misdetections. This vulnerability can be attributed to the complex structure of UNetPlus, which incorporates nested UNet structures and deep supervision mechanisms. Consequently, the model tends to overfit noise and struggles to effectively differentiate between fracture features and noise features, thereby compromising segmentation accuracy. Clearly outperforming the other models considered here, SWSDS-Net demonstrates superior segmentation performance. The SWS attention mechanism ensures equitable attention allocation and enhancement for both large and small objects, maximizing the detection of small targets without any omissions. Moreover, DSCN’s deformable properties enable adaptive sampling based on fracture shapes, facilitating improved extraction of fracture features. Additionally, SWSDS-Net adeptly captures intricate details, leading to near-perfect segmentation of fracture shapes while avoiding issues such as blurred edges or inaccurate shapes.

4. Conclusions

The proposed paper presents an end-to-end fracture segmentation algorithm for logging images, aiming to address the challenges of low segmentation accuracy in current algorithms when dealing with poor image quality, high noise interference, and complex shapes. Furthermore, it tackles the lack of lightweight models suitable for on-site deployment. The success of SWSDS-Net can be attributed to replacing standard convolution in UNet with the lightweight DSCN. By utilizing deformable convolution operations, DSCN enhances adaptability to target object shapes and achieves a global receptive field, enabling better capture of relationships between target objects. Additionally, the introduction of the SWS module after upsampling improves the network’s ability to capture global fracture information while maintaining a lightweight structure. This enhancement significantly boosts detection performance for small targets [36].

The experimental results demonstrate that, in comparison to currently prevalent fracture segmentation algorithms, the proposed SWSDS-Net exhibits superior overall performance and is better suited for fracture segmentation scenarios in imaging logging. Moreover, the lightweight model effectively addresses the challenge of on-site deployment on mobile devices. This paper holds significant practical value, as it provides a more dependable foundation for oil and gas exploration and development while promoting the application of deep learning technology in industrial domains. Furthermore, it enables deep learning to seamlessly facilitate traditional industrial scenarios, thereby reducing labor costs [37].

However, the proposed algorithm for logging fracture segmentation still has limitations in processing multimodal logging data. Multimodal logging data encompass diverse types of logging curves that reflect distinct rock physical properties and exhibit different feature representations. Furthermore, the fusion of multimodal data significantly amplifies the complexity of the model, resulting in a substantial increase in training time and computational costs. Therefore, future work will focus on incorporating multimodal feature fusion techniques to facilitate better integration of features from different modalities and extract more comprehensive feature information. Additionally, a modality-adaptive learning module will be devised to enable the model to learn appropriate strategies for feature extraction and fusion based on the characteristics of each modality. Building upon this foundation, lightweight model design will be considered by employing lighter feature extraction modules or attention mechanisms to reduce model complexity.