A Multi-Deep Learning Intelligent Surface Rock Crack Identification Method for Transmission Tower Siting

Abstract

Accurate identification of surface cracks is of great significance for the site selection of transmission towers, as it directly affects the safety and stability of power grid construction. Traditional manual inspection methods are labor-intensive and inefficient, making them inadequate for large-scale and high-precision applications. Consequently, intelligent crack recognition technologies are receiving increasing attention and adoption. This study proposes a novel surface crack identification method that integrates multiple neural networks, aiming to overcome the limitations of traditional crack identification approaches, such as low accuracy and poor generalization. The proposed framework incorporates a convolutional neural network (CNN)-based data filtering module and a crack segmentation module combining UNet and YOLOv8 architectures. Together, these components form a robust and accurate end-to-end crack identification system, which is further applied to the evaluation of rock fragmentation. To verify the effectiveness and accuracy of the proposed method, experiments were conducted on a rock crack dataset and compared against several existing approaches. The results demonstrate that the proposed method achieves superior performance in crack detection accuracy. Moreover, tests on various scenario datasets also yielded promising results, indicating the strong generalization ability and adaptability of the method.

1. Introduction

With the rapid development of China’s economy, the electric power industry has ushered in unprecedented opportunities. The large-scale construction of power facilities has expanded the coverage of transmission lines, while geological and environmental conditions in different regions directly affect their safety and reliability [1]. As shown in Figure 1, geologic hazards (e.g., avalanches, landslides, mudslides, and ground subsidence) pose serious threats to the stable operation of transmission lines, potentially leading to line interruptions, equipment damage, and even casualties [2,3]. Therefore, detailed geological surveys are essential before construction to assess disaster risks and enhance resilience.

According to the Code for Geologic Hazard Risk Assessment (GB/T 40112-2021) [4], surface cracks should be treated seriously in the assessment of geologic hazards. The presence of surface cracks may not only trigger uneven settlement of foundations but also be a precursor of larger-scale geohazards (e.g., landslides or ground collapse) [5]. Cracks on the rock surface can induce weathering and fragmentation due to moisture, chemical agents, plant root infiltration, or human activities. Under heavy loads, the rock may break along these cracks, potentially compromising the safety of power transmission towers. Therefore, accurate identification of surface cracks is of great practical significance for the siting and construction of transmission lines. However, traditional surface crack identification methods mainly rely on manual investigation and simple image processing techniques, such as impact echo methods [6], radar methods [7], infrared thermography methods [8], etc. The aforementioned methods are inefficient and subjective, making it difficult to satisfy large-scale and high-precision engineering demands. Especially in complex surface environments, manual recognition is easily affected by lighting, texture, and background interference, resulting in low recognition accuracy and poor generalization ability [9,10,11]. Therefore, it is of great practical significance to develop an efficient, accurate, and adaptable crack recognition method.

In recent years, surface crack identification has attracted the attention of many researchers. The most common crack recognition method is based on digital image processing to process the collected crack images and determine the location of the cracks. In 2003, Abdel Qader et al. [12] tried to use the image segmentation method for crack recognition, with the results confirming its great performance in terms of crack recognition. Subsequently, AyenuPrah et al. [13] and Wei et al. [14] added image denoising and image enhancement operations to preprocess images to enhance crack recognition accuracy. To cope with the problem of non-crack target interference and low robustness, Han [15] et al. further reduced the effect of noise based on spatial filtering of Gaussian function and top-hat transform. The above method can obtain relatively good crack recognition performance with a small data volume; however, it requires a complex feature engineering analysis process, which has limitations in practical applications.

The rapid development of artificial intelligence technology provides new solutions for surface crack recognition. Different from the above traditional image processing methods, deep learning methods automatically capture the regularities in pictures by using neural networks to solve the problems related to feature extraction [16,17,18]. A deep learning-based feature extractor can extract the regularities, such as crack edges, width, position, and brightness, hidden in the picture. Liu et al. [19] used a deep learning algorithm to automatically identify tunnel lining cracks. Fan et al. [20] proposed a supervised pavement crack detection method based on convolutional neural networks and solved the data imbalance problem by adjusting the ratio of positive and negative samples. Liu et al. [21] used the UNet model to identify cracks on concrete surfaces. Cao et al. [22] incorporated an attention mechanism into the encoder–decoder neural network structure to recognize pavement cracks. Al-Huda et al. [23] proposed a hybrid deep learning approach for crack localization and crack recognition on pavement crack images.

Despite the significant progress in existing research, the following shortcomings still exist: (1) traditional methods rely on manual feature extraction, making it difficult to adapt to complex and changing real-world scenarios; (2) existing deep learning models perform poorly when dealing with tiny cracks and complex backgrounds; and (3) most of the methods lack an end-to-end solution, which leads to low recognition efficiency. These problems limit the application and promotion of crack recognition technology in practical engineering.

In order to obtain an efficient, accurate, and highly generalized surface crack identification algorithm, a smart surface crack identification method that integrates multiple neural networks is proposed in this paper. We call it the MultiNet crack identification method. It involves the design of a crack classification strategy based on convolutional neural networks (CNN) to filter out images that do not contain cracks, thereby effectively enhancing the efficiency of subsequent crack identification. Subsequently, a crack identification algorithm based on the Unet-YoLo architecture is constructed, in which the Unet module is employed for the preliminary segmentation of crack images, and the YoLo module is utilized for the optimization of the identification results. The combination significantly reduces the interference of non-crack information, such as shadows and potholes, in the recognition outcomes. Finally, in order to validate the accuracy of the proposed algorithm, experiments are conducted on a surface rock crack dataset, and the results indicate that crack information can be accurately identified and extracted. Rock crack identification is a crucial basis for assessing the degree of surface fragmentation in rocks. Based on the fragmentation level, it is possible to preliminarily infer whether the geological conditions in the area are suitable for the construction of transmission towers. Generally, a high density of cracks and significant fragmentation in rocks can negatively impact the stability of transmission towers, making them susceptible to collapse due to unstable foundations. Additionally, to assess the generalization capabilities of the proposed algorithm, validations are performed on other crack identification scenarios, confirming that the algorithm demonstrates good crack identification performance across different scenarios.

Therefore, the research in this paper not only provides reliable technical support for transmission station siting but also promotes the development of intelligent crack identification and extraction technology, which has important theoretical value and engineering application significance.

2. Framework of the MultiNet Crack Identification Method

This section primarily presents the framework of the crack identification algorithm based on multiple deep learning techniques, as illustrated in Figure 2. The multi-deep learning framework for crack identification consists mainly of a crack image classification module based on the CNN, a crack segmentation module based on UNet, and an optimization module based on YOLOv8. The CNN-based image classification module is employed to perform preliminary filtering of images using a crack classification algorithm, facilitating the selection of images that exhibit crack features and enhancing the efficiency of subsequent crack identification. The UNet-based crack segmentation module utilizes an image segmentation model to achieve a probabilistic representation of crack features, thereby effectively extracting these features. To address the interference from factors such as shadows and potholes during the crack identification process, an optimization matrix for crack recognition based on YOLO was designed, which significantly reduces the influence of non-crack factors.

3. CNN-Based Image Classification Module

In order to effectively filter out images without crack features, a lightweight CNN-based image classification module was designed (Figure 3). The model contains four convolutional layers, four pooling layers, and two fully connected layers. It adopts a series of regularization methods to prevent overfitting and uses ReLU as the activation function.

3.1. Convolution Operation

Let $\mathsf{\chi }\in {\mathbb{R}}^{3\times m\times n}$ be the three-dimensional pixel tensor of the input RGB surface image, where $x_{k,i,j}\in \{\mathsf{\chi }$| k$\in \left[\mathrm{1,3}\right],i\in [1,m],j\in [1,n]$}. The core part of the CNN-based classification model designed is the convolutional layer, which gradually extracts the multi-level spatial features of the input image by means of the local sense field and weight sharing mechanism. Let ${\mathsf{\chi }}^{\left(l\right)}=\{x_{k,i,j}^{\left(l\right)}|k\in [1,C_{in}^{\left(l\right)}],i\in [1,H^{\left(l\right)}],j\in [1,W^{\left(l\right)}]\}$ be input tensor of the convolutional layer, where $l\in [1,4]$ is the number of convolutional layers, $C_{in}^{\left(l\right)}$ denotes the number of input channels at layer $l$, $H^{\left(l\right)}$ and $W^{\left(l\right)}$ denote the height and width of the input image of layer $l$, respectively. $x_{k,i,j}^{\left(l\right)}\in \mathbb{R}$ represents the pixel value of the input tensor at position $(i,j)$ of the channel k of the layer $l$. When $l$ = 1, ${\mathsf{\chi }}^{\left(l\right)}=\mathsf{\chi }$, $x_{k,i,j}^{\left(l\right)}$ = $x_{k,i,j}$.

Let $W^{\left(l\right)}\in {\mathbb{R} }^{C_{out}^{\left(l\right)}\times C_{in}^{\left(l\right)}\times K\times K}$ be the convolution kernel, where $C_{out}^{\left(l\right)}$ is the number of output channels of the layer $\mathrm{l}$, $\mathrm{K}$ is the convolution kernel size, and ${\mathit{W}}^{\left(l\right)}=\{w_{c,k,u,v}^{\left(l\right)}|c\in [1,C_{out}^{\left(l\right)}],k\in [1,C_{in}^{\left(l\right)}],u\in [1,K],v\in [1,K]\}$, where $w_{c,k,u,v}^{\left(l\right)}\in \mathbb{R}$ represents the weight value of the convolution kernel of the output channel $\mathrm{c}$ of the layer $\mathrm{l}$ to the input channel $k$ at position $(u,v)$. The corresponding bias vector is ${ b}^{\left(l\right)}=\{b_c^{\left(l\right)}|c\in [1,C_{out}^{\left(l\right)}]\}$.

The formula for the convolution operation is as shown in Equation (1):

$$y_{c,i,j}^{\left(l\right)}={\sum }_{k=1}^{C_{in}}{\sum }_{u=1}^K{\sum }_{v=1}^K{w}_{c,k,u,v}^{\left(l\right)}·x_{k,i+u-1,j+v-1}^{(l-1)}+b_c^{\left(l\right)}$$

(1)

In Equation (1), $(i,j)$ represents the position of the pixel values of the feature matrix, $x_{k,i+u-1,j+v-1}^{(l-1)}$ represents the pixel value of the channel $k$ of the input tensor of the layer $(l-1)$ at the position $(i+u-1,j+v-1)$. The number of channels in the convolutional layer starts from the three RGB channels of the input image, increases layer by layer to 48, 96, and 192, and finally decreases to 96 channels in the convergent convolutional layer. This design enhances the model’s ability to capture the local details and overall structural features of the cracks. In this paper, the convergent convolution operation uses 3 × 3 small convolution kernels, which can effectively capture the local details of the crack.

3.2. Pooling Operation

Each full convolution operation of the model is followed by a max pooling layer, using a 2 × 2 pooling kernel with a step size of 2. Assume that the convolutional layer $\mathrm{l}$ outputs a three-dimensional tensor ${\mathit{Y}}^{\left(l\right)}\in {\mathbb{R} }^{{ C}_{out}^{\left(l\right)}\times H_{out}^{\left(l\right)}\times W_{out}^{\left(l\right)}}$ consisting of $C_{out}^{\left(l\right)}$ two-dimensional feature maps. Its elements are $y_{c,i,j}^{\left(l\right)}\in \{Y^{\left(l\right)}|c\in [1,C_{out}^{\left(l\right)}],i\in [1,H_{out}^{\left(l\right)}],j\in [1,W_{out}^{\left(l\right)}]\}$, and the calculation formula is as follows:

$${pool}_{b,c,i,j}^{\left(l\right)}={max}_{0\le m,n\le 1}{y}_{b,c,si+m,sj+n}^{\left(l\right)}$$

(2)

where $\mathrm{m},\mathrm{n}$ represents the offset within the pooling kernel (with a value of 0 or 1), $\mathrm{s}$ represents the pooling step size (set to 3 in this paper), and $y_{b,c,si+m,sj+n}^{\left(l\right)}$ represents the value of the four-dimensional tensor output at the convolutional layer $l$ where the batch is $b$, channel is $c$, and position is $(si+m,sj+n)$.${ pool}_{b,c,i,j}^{\left(l\right)}$ represents a four-dimensional output tensor after pooling of layer $l$, where the batch is $b$, the channel is $c$, and the position is $(i,j)$.

3.3. BatchNorm2d+ Dropout Regularization

To improve the generalization ability of the model and reduce the risk of overfitting, BatchNorm2d+Dropout is used for regularization in convolutional layer operations. Specifically, BatchNorm is used to normalize the input data for each layer to speed up training and avoid gradient explosion or vanishing problems. The calculation formula is as shown in Equation (3):

$${\widehat{y}}_{b,c,i,j}^{\left(l\right)}={\gamma }_c^{\left(l\right)}·{\displaystyle \frac{y_{b,c,i,j}^{\left(l\right)}-{\mu }_c^{\left(l\right)}}{\sqrt{{({\sigma }_c^{\left(l\right)})}^2+ϵ}}}+{\beta }_c^{\left(l\right)}$$

(3)

where $y_{b,c,i,j}^{\left(l\right)}$ represents the values of input tensor in the layer $l$, where $b$ denotes the sample, $c$ denotes the channel, and $(\mathrm{i},\mathrm{j})$ denotes the position, ${\mu }_c^{\left(l\right)}$ and ${\sigma }_c^{\left(l\right)}$ respectively represent the data mean and standard deviation of the channel $\mathrm{c}$ at the layer $l$, ${\gamma }_c^{\left(l\right)}$ and ${\beta }_c^{\left(l\right)}$ respectively represent the learnable scaling factor and offset of the channel $\mathrm{c}$ at the layer $l$, $\mathsf{ϵ}$ is a minimal constant in case the denominator is 0, and ${\widehat{y}}_{b,c,i,j}^{\left(l\right)}$ represents the output tensor value after normalization and regularization transformation.

In addition, differential dropout regularization is used to break the co-adaptation between features and improve the generalization ability of the model. Specifically, the lower dropout rate (0.3, 0.3) is applied to the shallow and middle convolutional layers, while the higher dropout rate (0.5, 0.4) is applied to the deep and convergent convolutional layers. The dropout operation is given by Equation (4):

$${\tilde{y}}_{b,c,i,j}^{\left(l\right)}=p_{b,c,i,j}^{\left(l\right)}·{\widehat{y}}_{b,c,i,j}^{\left(l\right)}$$

(4)

where $p_{b,c,i,j}^{\left(l\right)}$ represents the probability that a mask tensor following a Bernoulli distribution is retained at position $(\mathrm{i},\mathrm{j})$, and ${\tilde{y}}_{b,c,i,j}^{\left(l\right)}$ represents the output tensor after dropout processing.

Finally, in this study, we use two fully connected layers to integrate the features extracted from the convolutional layers and output the final classification results. To further prevent overfitting, 0.5 dropout is used to regularize the fully connected layers.

3.4. Activation Function

This model uses ReLU as the activation function after each convolutional layer and the fully connected layer. The ReLU function effectively avoids the vanishing gradient problem and speeds up the training process. The calculation formula is as shown in Equation (5):

$$z_{b,c,i,j}^{\left(l\right)}=max(0,{\tilde{y}}_{b,c,i,j}^{\left(l\right)})$$

(5)

where ${\mathit{z}}_{\mathit{b},\mathit{c},\mathit{i},\mathit{j}}^{\left(\mathit{l}\right)}$ represents the output tensor after passing through the ReLU activation function.

3.5. Loss Function for the CNN-Based Image Classification Module

The cross-entropy loss, which is widely used in classification tasks, is adopted in this paper. This loss measures the deviation between the predicted probability and the true label, which helps to achieve steady gradient descent during training. The cross-entropy loss formula is as shown in Equation (6):

$$\mathcal{L}=-{\sum }_{i=1}^N[y_i\mathit{ln}\widehat{y_i}+(1-y_i\left)\mathit{ln}(1-\widehat{y_i})\right]$$

(6)

where $\mathcal{L}$ represents the loss value,$\mathrm{N}$ represents the number of categories of the sample, $N=2$ in the surface fissure classification scenario in this paper represents the predicted category of the model for the surface fissure image, and $\widehat{y_i}\in \{\mathrm{0,1}\} y_i\in \{\mathrm{0,1}\}$ represents the true category of the surface fissure.

4. UNet-YOLOv8 Crack Segmentation Module

A semantic segmentation model for crack identification was initially constructed based on the UNet architecture, yielding preliminary crack extraction results. The YOLOv8 model was subsequently employed to precisely locate crack regions. By integrating the detection boxes produced by YOLOv8 with the segmentation outcomes from UNet, the effects of confounding factors such as shadows and potholes on crack extraction were eliminated, thereby optimizing extraction performance. Specifically, the YoLov8 model provides accurate location information for cracks, while the UNet model offers detailed shape information. By utilizing the detection boxes from YoLov8 as prior information to constrain the segmentation results of UNet, occurrences of mis-segmentation can be effectively reduced, enhancing both the accuracy and robustness of crack extraction.

4.1. The Input of the Unet-YOLOv8 Model

The UNet architecture employed in this study consists of three components: an encoder (down-sampling path), a decoder (up-sampling path), and a skip connection mechanism. The encoder systematically extracts high-level semantic information from the input images through multiple down-sampling operations, simultaneously reducing the spatial resolution of the feature maps. This process is crucial for capturing the fundamental features of cracks at various scales. In contrast, the decoder progressively restores the spatial resolution of the feature maps via up-sampling while integrating features from the encoder stage. This integration enables the acquisition of rich detail information, which is essential for accurately delineating crack boundaries. Ultimately, the model outputs the probability values for each pixel belonging to the target category (i.e., crack or non-crack), achieved through the application of a Sigmoid activation function. The primary structure of the UNet network as applied to the crack identification scenario is illustrated in Figure 4.

Before being input into the model, both the original images and their corresponding binarized masks are loaded in single-channel grayscale mode. After pre-processing, these images are converted into tensors and input into the model in the form of a tensor. Let $\mathit{I}\in {\mathbb{R}}^{N\times C\times H\times W}$ be the input tensor, where $N$ represents the batch size, $C$ denotes the number of channels (for grayscale images, the value is set to 1), $H$ indicates the image height, and $W$ refers to the image width. During the pre-processing stage, all images are standardized to a size of 256 × 256 pixels.

4.2. Down-Sampling Spatial Encoding Layer

Subsequently, the input images are processed using a down-sampling spatial encoding layer, which reduces the spatial resolution of the feature maps while expanding the channel dimension to extract more abstract semantic information. Each down-sampling module consists of a max pooling layer and a double convolution module.

Let ${\mathit{U}}^{\left(l\right)}\in {\mathbb{R}}^{ N\times C^{\left(l\right)}\times H^{\left(l\right)}\times W^{\left(l\right)}}$ be the input tensor of the sampling module under the layer $l$, and the calculation formula for the double convolution operation of the 3 × 3 convolution kernel is as follows:

$${\mathit{Q}}^{\left(l\right)}=\sigma \left(\mathit{B}\mathit{n}\mathit{o}\mathit{r}\mathit{m}\right(w_2^{\left(l\right)}·\left[\sigma \right(BN(w_1^{\left(l\right)}·{\mathit{U}}^{\left(l\right)}+b_1^{\left(l\right)})\left)\right]+b_2^{\left(l\right)}\left)\right)$$

(7)

In Equation (7), $\mathrm{B}\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}$ represents the BatchNorm operation, $w_1^{\left(l\right)}$ and $w_2^{\left(l\right)}$ respectively represent the weights of the two convolution kernels of the layer $\mathrm{l}$, $b_1^{\left(l\right)}$ and $b_2^{\left(l\right)}$ respectively represent the bias of the two convolution operations of the layer $\mathrm{l}$, $\mathsf{\sigma }$ represents the ReLU activation function, and ${\mathit{Q}}^{\left(l\right)}$ represents the intermediate feature tensor obtained after the double convolution operation.

The model uses 3 × 3 convolution kernels to ensure adequate feature extraction, with a step size of 1 and a fill of 1. The formula for calculating the output feature map size is as follows:

$$H_{out}={\displaystyle \frac{H_{in}+2P-FH}{S}}+1,$$

(8)

$$W_{out}={\displaystyle \frac{W_{in}+2P-FH}{S}}+1.$$

(9)

In Equation (8), $H_{in}$ represents the height of the input feature map, $P$ is the number of fill layers, $FH$ is the height of the convolution kernel, $S$ is the step size, and $H_{out}$ is the height of the output feature map. In Equation (9), $W_{in}$ represents the width of the input feature map, $\mathrm{F}\mathrm{H}$ is the width of the convolution kernel, $W_{out}$ is the width of the output feature map, where $P$ and $S$ are consistent with those in Equation (8).

Therefore, it can be concluded from the equation that when the step size is set to 1, the fill is set to 1, and a double convolution operation is performed using a 3 × 3 convolution kernel, the size of the feature map remains the same during the convolution operation and the spatial dimension remains the same but the channel expression ability is enhanced.

After the double convolution module, spatial down-sampling is performed with a 2 × 2 max pooling kernel, and the calculation formula is as follows:

$${\mathit{P}}^{(l+1)}=\mathit{M}\mathit{a}\mathit{x}\mathit{P}\mathit{o}\mathit{o}\mathit{l}({\mathit{Q}}^{\left(l\right)})$$

(10)

In Equation (10), $\mathrm{M}\mathrm{a}\mathrm{x}\mathrm{P}\mathrm{o}\mathrm{o}\mathrm{l}$ represents the max pooling operation, ${\mathit{P}}^{(l+1)}$ represents the tensor output after one max pooling.

A double convolution operation and a max pooling operation constitute a complete down-sampling layer. The input feature tensor $\mathit{I}\in {\mathbb{R}}^{ N\times C\times H\times W}$ undergoes four consecutive down-sampling operations, doubling the number of channels at each step and reducing the height and width of the feature map to half of its original size. Ultimately, the output tensor $\widehat{\mathit{I}}\in {\mathbb{R} }^{ N\times 1024\times 16\times 16}$ enters the decoder section. Through these four down-sampling operations, the model successfully extracted advanced semantic information from the image, laying a solid foundation for subsequent up-sampling operations. At the encoder stage, each down-sampling layer effectively reduced the spatial resolution of the feature map while significantly increasing the number of channels, enabling the model to capture more abstract and complex features in the image. This design enables the model to better understand the content of the image, providing strong support for the precise segmentation of cracks.

4.3. Up-Sampling Spatial Encoding Layer

The up-sampling spatial decoder is employed to gradually restore the spatial resolution of the feature maps while integrating the features collected during the encoder phase to obtain richer detail information. Each up-sampling module consists of a transpose convolution operation followed by a dual-convolution module. Through skip connections, the decoder can merge features from the encoder phase, allowing it to retain more detailed information while recovering the spatial resolution.

Let ${\mathit{T}}^{\left(l\right)}\in {\mathbb{R}}^{N\times C^{\left(l\right)}\times H^{\left(l\right)}\times W^{\left(l\right)}}$ is the input vector of the sampling module on the layer $l$, where $N$ represents the batch size, $C^{\left(l\right)},H^{\left(l\right)}$ and $W^{\left(l\right)}$ represents the number of channels, height, and width of the feature map of that layer, respectively.

The transposed convolution operation uses the transposed matrix to expand the spatial dimension of the feature map, as shown below:

$${\mathit{Z}}^{\left(l\right)}=\mathit{C}\mathit{o}\mathit{n}\mathit{v}\mathit{T}\mathit{r}\mathit{a}\mathit{n}\mathit{s}\mathit{p}\mathit{o}\mathit{s}\mathit{e}\left(t^{\left(l\right)}\right)$$

(11)

In Equation (11), ${\mathit{Z}}^{\left(l\right)}\in {\mathbb{R}}^{ N\times {\displaystyle \frac{C^{\left(l\right)}}{2}}\times 2H^{\left(l\right)}\times 2W^{\left(l\right)}}$ represents the feature tensor obtained from the transposed convolution of layer $\mathrm{l}$, with the kernel size set to 2 × 2 and the span set to 1. After transposed convolution, the number of channels is halved and the spatial dimension is doubled.

Then, the up-sampled feature tensor ${\mathit{Z}}^{\left(l\right)}$ is concatenated with the corresponding feature tensor ${\mathit{Q}}^{\left(l\right)}\in {\mathbb{R}}^{ N\times {\displaystyle \frac{C^{\left(l\right)}}{2}}\times 2H^{\left(l\right)}\times 2W^{\left(l\right)}}$ of the encoder stage in the channel dimension, as shown below:

$$\widehat{{\mathit{Z}}^{\left(l\right)}}=\mathit{C}\mathit{o}\mathit{n}\mathit{c}\mathit{a}\mathit{t}({\mathit{Z}}^{\left(l\right)},{\mathit{Q}}^{\left(l\right)})$$

(12)

In Equation (12), $\widehat{Z^{\left(l\right)}}\in {\mathbb{R} }^{ N\times C^{\left(l\right)}\times {2H}^{\left(l\right)}\times 2W^{\left(l\right)}}$ represents the output tensor after the jump connection fusion of layer $\mathrm{l}$.

Perform a double convolution operation on the merged feature tensor $\widehat{{ Z}^{\left(l\right)}}$. Consistent with the down-sampling stage, use 3 × 3 convolution kernels to ensure sufficient feature extraction, with a step size of 1 to maintain the feature map size while halving the number of channels. This, combined with batch normalization and the ReLU activation function, completes a full up-sampling process. After four consecutive up-sampling operations, output the tensor ${\mathit{O}}_{\mathit{f}\mathit{i}\mathit{n}\mathit{a}\mathit{l}}\in {\mathbb{R} }^{ N\times 64\times 256\times 256}$ as the output of the up-sampling module.

4.4. Output of the UNet Module

The output layer includes a convolution operation that uses a 1 × 1 convolution kernel to reduce the number of channels in the feature map to the number of target categories (1 in this article) $\widehat{{\mathit{O}}_{\mathit{f}\mathit{i}\mathit{n}\mathit{a}\mathit{l}}}\in {\mathbb{R}}^{N\times 1\times 256\times 256}$. The Sigmoid activation function is then applied to map the output values to a range of [0, 1] representing the probability that each pixel belongs to the target category. The formula is as follows

$$ans={\displaystyle \frac{1}{1+e^{-\widehat{{\mathit{O}}_{\mathit{f}\mathit{i}\mathit{n}\mathit{a}\mathit{l}}}}}}$$

(13)

In Equation (13), $ans\in {\mathbb{R}}^{N\times 1\times 256\times 256}$ is the probability value tensor of each pixel in the feature map.

Through the above steps, the model can effectively extract the crack feature and output the probability value that each pixel belongs to the target category, thereby achieving a probabilistic representation of the crack feature. This design enables the model to better understand the content of the image, providing strong support for precise crack segmentation.

4.5. Loss Function for the UNet-YOLOv8 Crack Segmentation Module

For the crack segmentation task, we adopt a composite loss function consisting of Binary Cross-Entropy (BCE) loss and Dice loss. BCE measures the discrepancy between predicted and actual pixel labels ${\mathit{O}}_{ground}$, shown in Equation (14), while Dice loss emphasizes the overlap between predicted and ground truth regions, shown in Equation (15), which is especially important for handling the class imbalance between crack and background pixels. The combined loss is defined as Equation (16). $\epsilon$ represents a very small value, and $\alpha \in$ (0, 1) is the balance weight.

$${\mathcal{L}}_{BCE}=-[{\mathit{O}}_{ground}\cdot log({\widehat{{\mathit{O}}_{final}}}_{finalOut})+(1-{\mathit{O}}_{ground})\cdot log(1-{\widehat{{\mathit{O}}_{final}}}_{finalOut}\left)\right],$$

(14)

$${\mathcal{L}}_{\mathrm{Dice} }=1-{\displaystyle \frac{2O_{ground}\widehat{{\mathit{O}}_{final}}+\epsilon }{O_{ground}+\widehat{{\mathit{O}}_{final}}+\epsilon }}$$

(15)

$${\mathcal{L}}_{\mathrm{seg} }=\alpha \cdot {\mathcal{L}}_{\mathrm{BCE} }+(1-\alpha )\cdot {\mathcal{L}}_{\mathrm{Dice} }$$

(16)

4.6. YOLOv8-Based Boolean-Type Identification Optimization Matrix

Considering that interference information, such as shadows that resemble cracks, can arise during crack feature extraction and lead to mis-identification of similar features as cracks, thereby affecting engineering judgments, this study introduces a Boolean-type identification matrix optimization algorithm based on YOLOv8.

This method first employs the YOLOv8 object detection algorithm to obtain the relative position vector $\left[x_{center},y_{center},width,height\right]$ of cracks in the input feature map, where ${(x}_{center},y_{center})$ represents the coordinates of the bounding box center, and $\mathrm{w}\mathrm{i}\mathrm{d}\mathrm{t}\mathrm{h},\mathrm{h}\mathrm{e}\mathrm{i}\mathrm{g}\mathrm{h}\mathrm{t}$ denotes the relative width and height of the bounding box.

Based on the bounding box information $\left[x_{center},y_{center},width,height\right]$, the absolute positions of the four vertices of the crack feature bounding box can be determined, with the calculation formulas being as follows:

$${\mathrm{x}}_{\mathrm{m}\mathrm{i}\mathrm{n}}=(x_{center}-{\displaystyle \frac{width}{2}})\times w_{\mathrm{i}\mathrm{m}\mathrm{g}},$$

(17)

$${\mathrm{y}}_{\mathrm{m}\mathrm{i}\mathrm{n}}=\left(y_{center}-{\displaystyle \frac{height}{2}}\right)\times h_{\mathrm{i}\mathrm{m}\mathrm{g}},$$

(18)

$${\mathrm{x}}_{\mathrm{m}\mathrm{a}\mathrm{x}}=\left(x_{center}+{\displaystyle \frac{width}{2}}\right)\times w_{\mathrm{i}\mathrm{m}\mathrm{g}},$$

(19)

$$y_{\mathrm{m}\mathrm{a}\mathrm{x}}=(y_{center}+{\displaystyle \frac{height}{2}})\times h_{\mathrm{i}\mathrm{m}\mathrm{g}}.$$

(20)

In the above equations, $w_{img}$ is the width of the original picture (usually 256), $h_{img}$ is the height of the original picture (usually 256), $x_{min} \mathrm{a}\mathrm{n}\mathrm{d} x_{max}$ are the left and right boundaries of the bounding box, and $y_{max} \mathrm{a}\mathrm{n}\mathrm{d} y_{min}$ are the left and right boundaries of the bounding box, respectively.

As a result, a Boolean identification matrix (MaskMap) with a size of $w_{img}$ × $h_{img}$ and initialized to False can be established for modeling the presence or absence of crack features in the feature map region. Based on the location information $\left[x_{min},x_{max},y_{min,}{y}_{max}\right]$, it can be determined that crack features exist in this range, thus marking the feature points in this range of the MaskMap as True. through the input of multiple bounding box information, MaskMap has the ability to represent the existence of crack regions.

The mask map ${\mathit{O}}_{finalOut}$ of the crack extraction results obtained through the UNet model is binarized to obtain the feature matrix ${\mathit{O}}_{mask}$ consisting of 0 and 1. At this time, the MaskMap and ${\mathit{O}}_{mask}$ are of the same size, and the corresponding positional data are multiplied together to form the optimized mask image (OptimizedMask):

$$OptimizedMask\left(i,j\right)=MaskMap\left(i,j\right)\times O_{mask}\left(i,j\right).$$

(21)

In Equation (21), i and j are the data positions in the feature matrix, respectively. Taking the 5 × 5 pixel crack feature map as an example, the optimization mask image formation principle is shown in Figure 5.

The pixels marked in red in $O_{mask}$ are the initially extracted pixels (1 is the crack feature and 0 is the background feature), the red box in the MaskMap is the crack feature area within the range and the background feature area outside the range, and the two are superimposed to retain only the crack features within the crack feature area. The optimized mask image is obtained to ensure that the extraction range is constrained to within the labeled box.

Pixel-level crack detection is performed on the input image using the UNet model, and the probability distribution map of cracked pixels is obtained, i.e., the value of each pixel point indicates the probability that the point is a crack. Subsequently, combined with the mask generated by the YOLOv8 frame label (MaskMap), the predicted probability map of the UNet model is multiplied with MaskMap on a pixel-by-pixel basis to achieve the optimization of the probability values. In the YOLOv8 recognition range, the probability value remains unchanged, while outside the range, the probability value is set to 0. This process effectively removes the possible misdetection area of the UNet model and at the same time retains the complete structural information of the cracks, which provides more accurate and reliable basic data for the generation of the subsequent thermodynamic diagram. The optimized thermodynamic diagram effectively eliminates the interference of crack-like features (e.g., shadows, etc.), which is significantly useful for engineering crack extraction.

5. Experiments and Analysis

Considering that the MultiNet crack identification method comprises two distinct steps, a CNN-based crack classification module and a UNet-YOLO-based crack segmentation module, each implemented using an independent neural network architecture, this paper conducts separate experiments and analyses for each component.

5.1. Experimental Preparation

All experiments were conducted on a personal computer running the Windows operating system, equipped with an NVIDIA GeForce RTX 4060 GPU. The deep learning framework used is PyTorch 2.4.1 with CUDA version 11.8.

In order to validate these two modules with different functions separately, two datasets were selected for experiments:

Dataset for the CNN-based crack classification module: An open-source, publicly available surface crack dataset was used as the dataset for the CNN-based crack classification module. The original crack dataset was manually screened and divided into images with crack features and those with non-crack features. The training dataset used in this paper comprises 4900 images. The images were divided into a training set (80%) and a validation set (10%) for real-time monitoring of the training process. To ensure the practicability of the model, a separate test dataset was prepared. Specifically, the test dataset comprised 2600 images. These images were carefully labeled to ensure accurate feature identification. Additionally, median filtering was applied to remove noise from the images.

Dataset for the UNet-YOLOv8-based crack segmentation module: An open-source, publicly available dataset of 2083 high-resolution (256 × 256) crack images with corresponding manually annotated binary masks was used as the dataset. The dataset encompasses various complex scenarios, including open cracks, closed cracks, high-density distribution cracks, and low-density distribution cracks, covering diverse lighting conditions and background interference scenarios. The dataset was divided into a training set (1666 samples) and a validation set (417 samples) with an 8:2 ratio. Additionally, 100 crack feature maps of four types were prepared as the test set. The data distribution is shown in

Table 1. Distribution of datasets.

Dataset	Training Set	Validation Set	Test Set
Quantities	1666	417	100

:

5.2. Experimental Settings and Result Analyses

5.2.1. For the CNN-Based Crack Classification Module

(1) 

Experimental setting and process

Before the experiment was carried out, the image data were first denoised. The dataset was denoised through median filtering. Then, normalization was carried out, and the image size was uniformly adjusted to 128 × 128 pixels. Since there are significantly more crack feature images than non-crack feature images, unbalanced data augmentation was adopted for the two different feature images. For images with crack features, on-the-fly rotation and horizontal flip were performed. For images without crack features, on-the-fly rotation, horizontal flip, vertical flip, color dithering, on-the-fly auto-contrast, and random histogram averaging were carried out to reduce the training data imbalance problem due to unbalanced data augmentation.

Table 2. The main hyperparameter settings for the CNN-based crack classification module.

Main Hyperparameters	Value
Batch size	32
Epochs	200
Learning Rate Tuning Scheduler (LRTS)	StepLR
Decay factor for the LRTS	0.3
Patience for the LRTS	40
Initial learning rate	0.004
Optimizer	AdamW
Weight decay	$0.0001$

illustrates that the experiment was conducted over 200 training epochs using a batch size of 32. Optimization was performed with the AdamW optimizer, initialized with a learning rate of 0.004, and incorporates the StepLR scheduler, which reduces the learning rate by a decay factor of 0.3 every 40 training epochs (denoted as patience). Additionally, a weight decay of 0.0001 was applied.

During the training process, the model adjusts the network parameters using a back-propagation algorithm to minimize the loss function (cross-entropy loss). During the training process, a validation set is used to monitor the overfitting situation and adjust the training strategy based on validation accuracy. After each iteration, the accuracy and loss values on the training and validation sets are recorded so that the training effect of the model can be analyzed. After training, the model is evaluated using a test set to check the generalization ability of the model on unseen data. The performance of the model is evaluated by calculating the accuracy of the test set. Based on the evaluation results, the hyperparameters of the model (e.g., learning rate, dropout ratio, etc.) are further tuned to improve the model’s performance.

Table 3. Analysis and comparison under different combinations of training process hyperparameters.

Parameter Combination	Parameter Settings					Training Process			Testing Accuracy
	Conv	Pooling	FC	Channel	Regularized Distribution (Dropout)	Lr Initialization	Optimizer	Scheduler
C1	4	4	2	3-48-96-192-96	0.2 0.3 0.6 0.4	0.004	AdamW	StepLR	92.88%
C2	4	4	2	3-48-96-192-96	0.3 0.3 0.5 0.4	0.004	AdamW	StepLR	93.23%
C3	4	4	2	3-32-64-128-48	0 0.2 0.5 0.3	0.004	AdamW	StepLR	89.61%
C4	4	4	2	3-48-96-192-96	0.2 0.3 0.6 0.4	0.004	AdamW	CosineAnnealingLR	92.69%
C5	4	4	2	3-48-96-192-96	0.3 0.3 0.5 0.4	0.004	AdamW	CosineAnnealingLR	93.04%
C6	4	4	2	3-32-64-128-48	0 0.2 0.5 0.3	0.004	AdamW	CosineAnnealingLR	91.70%

demonstrates the detailed process of model evaluation and tuning, and by comparing the information in Table 3 and Figure 6, C2 was finally selected as the optimal hyperparameter combination.

To balance the complex scenario and the inferring accuracy, a network architecture consisting of four convolutional layers, four pooling layers, and two fully connected layers was adopted. Based on the determination of the number of weight layers, the number of channels takes the variation of 3-48-96-192-96. Compared to the 3-32-64-128-48 channel variation in Table 2, the former allows the model to capture more complex and abstract features at a deeper level. Moreover, the extraction of fine feature information, such as crack morphology and texture, is more adequate. The latter channel variation is smoother, which helps prevent the model from becoming overly complex. However, the smaller number of channels restricts the amount of feature information that the model can learn when dealing with complex images. This limitation leads to the model’s insufficient coping ability for complex road crack recognition.

To prevent model overfitting, Dropout2d was used. Relatively low on-the-fly discard rates were set in the shallow convolutional layers (layers 1 and 2), while higher on-the-fly discard rates were adopted in the deeper convolutional layers (layers 3 and 4), so as to reduce the model’s dependence on specific features and improve robustness. During the experiments, it was found that the model performs better when the Dropout2d allocation is relatively smooth than when the allocation variance is large. The smooth allocation helps the model to maintain the stability of continuous learning during the training process and promotes the neural network to gradually construct a hierarchical structure of features from simple to complex. If the follow-through discard rate varies too much from layer to layer, this can easily cause the model to over-rely on certain features in the early stage of training and ignore other potentially important information. In addition, a too high on-the-fly discard rate may also cause information loss and affect the learning effect. The optimal allocation scheme of 0.3, 0.3, 0.5, and 0.4 for the on-the-fly discard rate was finally determined.

The initial learning rate of 0.004 not only avoids instability during the training process but also ensures that the model learns and converges at an appropriate rate, ensuring that the model learns the basic features quickly in the early stage of training and makes fine adjustments in the later stage. In the choice of learning rate scheduler, a comprehensive comparison of StepLR and CosineAnnealingLR was carried out. It was found that the former learning rate scheduling is more convenient and accurate, and the appropriate step size adjustment makes the model training from shallow to deep and accelerates model convergence; in comparison, the latter scheduling method is not good for the convergence of the model, and the fluctuation of the loss value is large. Therefore, StepLR was used as the learning rate scheduler.

(2) 

Experimental results

(i) Accuracy and Convergence for Loss Value: In the model training phase, after 200 iterations of training, the accuracy of the model on the training set was stable at 98%, and the accuracy of the test set was stable at 96.41%. During the experimental process, the loss value gradually decreased and finally converged to a stable value, indicating that the model has fully learned the features in the data and that the training process does not show an overfitting phenomenon, as shown in Figure 6.

In the model testing phase, the model achieved an accuracy of 93.23% on the test set, which verifies the effectiveness and usefulness of the model in practical applications and confirms the excellent performance of the model in the crack recognition task. The small error in the test set proves that the model is robust in the classification of crack images.

(ii) Comparisons with Other Methods:. In order to verify the performance of the proposed model, we compared it with other advanced machine learning models, and the experimental results are shown in

Table 4. Comparisons with other state-of-the-art methods.

Methodologies	CNN-Based Classification Method	Support Vector Machine	Random Forest	Naive Bayes (Math.)	Decision Tree
Accuracy	96.41%	87.14%	92.16%	65.33%	87.63%
Recall rate	96.04%	85.87%	95.63%	64.96%	95.13%
F1-value	95.94%	87.14%	95.88%	77.56%	94.66%
Mean average precision (mAP)	96.43%	90.32%	94.88%	69.64%	94.66%

. Four methods, Support Vector Machine (SVM), Random Forest, Naive Bayes, and Decision Tree, were selected for the comparison test. The SVM method is a supervised learning algorithm that maximizes the boundary between different classes by finding the optimal segmentation hyperplane, which is especially suitable for high-dimensional data processing. The Random Forest method is a multi-decision tree model based on integrated learning. It improves generalization capabilities through a voting mechanism, but it has limited ability to extract complex texture features. The Naive Bayes method is based on the Bayesian model, which is suitable for simple scenarios. The Decision Tree adopts an intuitive tree structure for feature partitioning.

Through the experimental comparative analysis, the test accuracies of each comparison model were 87.14%, 92.73%, 65.33%, and 87.63%, respectively. The results show that the crack recognition method based on the CNN model proposed in this paper exhibits significant advantages considering Accuracy, Recall rate, F1-value, and Mean average precision.

5.2.2. For the UNet-YOLOv8 Crack Segmentation Module

(1) 

Experimental setting and process

YOLOv8 and UNet were trained in a parallel framework sharing the same preprocessed dataset. YOLOv8 training focuses on the detection task, optimizing bounding box regression and crack presence classification using Binary Cross-Entropy loss. U-Net training targets pixel-level segmentation, optimizing learning rate and weight decay parameters. After each training epoch, YOLOv8 outputs detection boxes while UNet generates pixel-level crack probability maps. All mentioned preprocessing operations, including spatial transformations and dataset partitioning, are applied before experimentation.

Table 5. The main hyperparameter settings for the UNet-YOLOv8 crack segmentation module.

Main Hyperparameters	Value
Batch size	16
Epochs	100
Learning Rate Tuning Scheduler (LRTS)	ReduceLROnPlateau
Decay factor for LRTS	0.5
Patience for LRTS	8
Initial learning rate	$0.001$
Optimizer	AdamW
Weight decay	$0.0001$

shows the main hyperparameter settings for the UNet-YOLOv8 crack segmentation module. Table 5 demonstrates that the experiment consists of 100 training epochs using a batch size of 16. The AdamW optimizer is utilized with specific parameters (weight decay = 0.0001 and initial learning rate = 0.001), in conjunction with the ReduceLROnPlateau scheduler. The scheduler is configured to monitor validation loss, with a decay factor of 0.5 and a patience of 8 epochs.

Preprocessed images are fed simultaneously into UNet and YOLOv8 for iterative training. The UNet updates parameters through backpropagation using BCELoss:

$$L=-{\displaystyle \frac{1}{N}}\sum _{i=1}^N\left[y_i·\mathit{ln}{x}_i+(1-y_i)·\mathit{ln}{(1-x}_i)\right]$$

(22)

In Equation (22), $\mathrm{N}$ is the total number of pixel points, ${\mathrm{y}}_{\mathrm{i}}$ is the true label, and ${\mathrm{x}}_{\mathrm{i}}$ is the probability value predicted by the model.

The model parameters are updated using the AdamW optimizer, and the learning rate is dynamically adjusted via the ReduceLROnPlateau scheduler. To enhance generalization and prevent overfitting, we implemented early stopping (15-epoch patience on validation IoU plateau) and metric monitoring.

In order to better evaluate the performance of the model, this experiment was analyzed using a Confusion Matrix. The Confusion Matrix is denoted as follows:

$$Confusion Matrix=\left[\begin{array}{cc}\mathrm{T}\mathrm{P}& \mathrm{F}\mathrm{P}\\ \mathrm{F}\mathrm{N}& \mathrm{T}\mathrm{N}\end{array}\right].$$

In this case, $\mathrm{T}\mathrm{P}$ (true positive example) is the sample that predicts the same positive class (crack) as the label, $\mathrm{T}\mathrm{N}$ (true negative example) is the sample that predicts the same negative class (background) as the label,$\mathrm{F}\mathrm{P}$ (false positive example) is the sample that predicts the positive class as the negative class, and $\mathrm{F}\mathrm{N}$ (false negative example) is the sample that predicts the negative class as the positive class. A model that performs well should have the following characteristics:$\mathrm{T}\mathrm{P}$ and $\mathrm{T}\mathrm{N}$ are large enough while $\mathrm{F}\mathrm{P}$ and $\mathrm{F}\mathrm{N}$ are small enough.

The model passes in a standard mask map and generates a copy of the mask map in the validation phase, and the two were compared at the pixel level to obtain the four base sample numbers of TP, TN, FP, and FN. This experiment uses four kinds of evaluation metrics, Precision, Recall, Accuracy, and Specificity, which are shown in Equations (23)–(26).

$$Precision={\displaystyle \frac{TP}{TP+FP}}$$

(23)

$$Recall={\displaystyle \frac{TP}{TP+FN}}$$

(24)

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

(25)

$$Specificity={\displaystyle \frac{TN}{TN+FP}}$$

(26)

In Equations (23)–(26), $\mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}$ denotes the percentage of real cracked pixels among the pixels predicted to be cracked $, \mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}$ denotes the percentage of correctly predicted pixels among the real cracked pixels $, \mathrm{A}\mathrm{c}\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{y}$ denotes the percentage of correctly predicted pixels among the total pixels, and $\mathrm{S}\mathrm{p}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{f}\mathrm{i}\mathrm{c}\mathrm{i}\mathrm{t}\mathrm{y}$ denotes the percentage of correctly predicted pixels among the real background pixels.

Based on the four model metrics, U-Net model performance can be clearly and comprehensively evaluated. By training and validating the model under different parameter settings, the experiment records the trends and stable values of Precision, Recall, Accuracy, and Specificity during the training process. These metrics provide the experiments with a comprehensive view of model performance.

(2) 

Experimental results

In order to verify the effectiveness and accuracy of the method, this section compares the crack identification results using this paper’s method with the original map and conducts ablation experiments to verify the enhancement of the identification effect of the method by the optimization module based on YoLoV8 as well as heat map processing, as shown in Figure 7. Figure 7a is the original rock crack image. Figure 7b is the identification result under an unoptimized mask map, wherein the optimization module and color-mapped operation are not used. Figure 7c is the identification result under an unoptimized heat map, wherein the optimization module is not used. Figure 7d is the identification result, wherein the optimization module and the color-mapped operation are all used. Figure 7 shows that the optimization module based on YoLoV8 can significantly improve the crack feature identification accuracy of the identification method and substantially reduce the influence of non-crack factors (e.g., shadows) on the identification results. Therefore, it can be inferred that the accurate localization of crack features based on YOLOv8 and the pixel-level crack feature extraction of the U-Net model in this paper can effectively avoid the interference of class crack features. Moreover, color-mapped heat maps can better show the connectivity of cracks.

Additionally, the various evaluation metrics are presented in Figure 8. Figure 8 shows that the Precision rate, the Recall rate, the Accuracy rate, and the Specificity converge to 79%, 70%, 97.5%, and 98.9%, respectively, during the training process. The numbers mean that the model has good reliability, and most of the regions predicted to be cracks are indeed crack features. The model is also able to capture the vast majority of crack features, with nearly all of the pixel points correctly classified. Additionally, the model has a very high accuracy rate in recognizing non-cracked pixels. The training and validation loss values decay smoothly, and the final fit is realized without overfitting. Therefore, the U-Net model and the training mechanism perform as expected.

After YOLOv8 optimization, the interference of large shadows, pits, and other crack-like features was excluded, and the pixels predicted to be crack features have a larger proportion of real crack pixels. Consequently, Precision was significantly improved in the test set images, with the average Precision increasing to 90.03%, and the other metrics were relatively stable. Moreover, Figure 9 shows that the loss value curves tend to converge after 80 iterations. This verifies the reasonableness of the training part of the setup in this paper.

Meanwhile, the experiments also added an asphalt pavement crack figure, a concrete crack figure, and a wall crack figure as test sets to verify the generalization ability of the model, shown in Figure 10. The results show that the method can also accurately extract crack information from other scenarios.

6. Conclusions

With the rapid development of electric power facilities, surface crack identification is crucial for transmission station siting and safety assessment. Traditional methods rely on manual surveys and simple image processing, which have problems of low efficiency and poor accuracy. This paper proposes a novel surface crack identification framework, which significantly enhances the accuracy and generalization capabilities of traditional crack detection methods by innovatively integrating various neural network approaches. Our experimental results indicate that the proposed end-to-end identification method, which includes a CNN-based data filtering module and a crack extraction module combining UNet and YOLO architectures, demonstrates good identification accuracy on rock crack datasets. This suggests that it can effectively support the site selection of transmission towers in power engineering, thereby enhancing the safety and stability of power grid construction. Through intelligent crack recognition technology, it can better address the demands of large-scale and high-precision crack detection, providing a reliable solution for future infrastructure monitoring and maintenance. Additionally, tests on different scenario datasets also reveal the strong generalization ability and adaptability of the method, making it applicable in other crack recognition scenarios.