A sample generation method and system for belt longitudinal tear detection

Abstract

The present application relates to the technical field of image processing, in particular to a sample generation method and system for belt longitudinal tear detection, the method comprising the following steps: acquiring real samples under normal state of the belt and when there is longitudinal tear, to construct a sample dataset and an abnormal patch library; constructing a sample generation network based on a feature decoupling autoencoder and a generative adversarial network; training the sample generation network using the sample dataset to obtain a sample generation model, which is used to generate a large number of candidate samples, and abnormal patches are extracted from the abnormal patch library and spliced with the candidate samples to obtain an enhanced sample set. The present application constructs a sample generation model by fusing the structured latent space learning ability of the variational autoencoder and the high-fidelity generation ability of the generative adversarial network, which is used to generate laser damage feature samples, and can solve the problems of insufficient sample quantity and poor feature robustness when extracting belt damage features by traditional laser scanning.

Description

Technical Field

[0001] This invention relates to the field of image processing technology, and in particular to a sample generation method and system for detecting longitudinal tearing of belts. Background Technology

[0002] Belt conveyors are core equipment for material transport in industrial production, and surface damage (such as cracks, holes, and wear) can lead to serious safety accidents such as belt tearing. Among traditional detection methods, laser scanning technology is widely used to extract belt damage characteristics due to its high precision and non-contact advantages. However, the following problems exist in practical applications: Sample scarcity: Severely damaged samples (such as tears) are rare during normal operation, resulting in a severe shortage of training data; Blurred features: Oil stains, water stains, or laser scanning angle deviations on the belt surface can blur the damage edge features, affecting detection accuracy. Traditional preprocessing methods can usually only handle some simple and obvious interference factors. For complex and variable environmental interferences, such as different types and degrees of oil stains, water stains, and randomly occurring light spots, it is difficult to achieve comprehensive and accurate removal; Poor generalization: Traditional machine learning models rely on manually designed features (such as edge gradients and area thresholds), which have weak adaptability to complex environments and poor robustness. Although Generative Adversarial Networks (GANs) can generate realistic samples, their latent space lacks structured constraints and is prone to pattern collapse; Variational Autoencoders (VAEs) can learn continuous latent distributions, but the generated samples lack sufficient detail realism. Summary of the Invention

[0003] To address the shortcomings of existing technologies, this invention provides a sample generation method and system for detecting longitudinal tearing of belts.

[0004] To achieve the above objectives, in a first aspect, this invention provides a sample generation method for detecting longitudinal tears in conveyor belts. The method includes the following steps: acquiring real samples of the conveyor belt under normal conditions and when longitudinal tears are present, to construct a sample dataset and an anomaly patch library; constructing a sample generation network based on a feature-decoupled autoencoder and a generative adversarial network; training the sample generation network using the sample dataset, optimizing the network through a hierarchical joint loss function to ensure that the generated samples match the real distribution at both the data and feature levels, thus obtaining a sample generation model; generating a large number of candidate samples using the trained sample generation model, and extracting anomaly patches from the anomaly patch library and combining them with the candidate samples to obtain an enhanced sample set. This invention constructs a sample generation model by fusing the structured latent space learning capability of a variational autoencoder with the high-fidelity generation capability of a generative adversarial network to generate laser damage feature samples. This solves the problems of insufficient sample quantity and poor feature robustness in traditional laser scanning for extracting conveyor belt damage features, and is particularly suitable for online monitoring of conveyor belts in complex environments such as coal mines and ports.

[0005] Optionally, the sample generation network includes a feature decoupling autoencoder, a feature extractor, and a discriminator.

[0006] Optionally, the feature-decoupled autoencoder includes an encoder and a decoder.

[0007] Optionally, the encoder is used to map the real sample into two independent latent variable distribution parameter vectors and generate two decoupled latent features through random sampling.

[0008] Optionally, the encoder reconstructs the real sample using the latent features and the jump output from the encoder to obtain a reconstructed image.

[0009] Optionally, the potential features include core features and redundant features.

[0010] Optionally, the discriminator includes a data discriminator and two potential discriminators; the input of the data discriminator is the real sample or the reconstructed image, and the output is a realism score of the reconstructed image; the input of the potential discriminator is the latent feature and the corresponding prior latent variable sampled from the standard normal prior distribution, and the output is the feature realism probability.

[0011] Optionally, the hierarchical joint loss function satisfies the following relationship:

[0012] in, For the total loss, The reconstruction loss of the autoencoder is used to decouple the features. For feature decoupling loss, To counteract the loss of the data discriminator in the decoder Loss of the decoder against the potential discriminator For feature matching loss, , , , and For trainable weights, .

[0013] Optionally, the sample generation network is trained using the sample dataset, and the decoder is ultimately used as the sample generation model.

[0014] Secondly, the present invention provides a sample generation system for detecting longitudinal tearing of belts. The sample generation system for detecting longitudinal tearing of belts includes: a data acquisition device, a data output device, a processor, and a storage device. The storage device includes a computer-readable storage medium storing a computer program. The computer program includes program instructions, which, when executed by the processor, cause the processor to implement the sample generation method for detecting longitudinal tearing of belts provided by the present invention.

[0015] In summary, the present invention has at least the following beneficial effects: 1. This method addresses the problems of insufficient sample quantity and poor feature robustness caused by environmental interference when extracting belt damage features using traditional laser scanning. It constructs a sample generation model by integrating the structured latent space learning capability of VAE with the high-fidelity generation capability of GAN.

[0016] 2. This method can generate a large number of high-quality and diverse laser damage feature samples without preprocessing the sample data, thereby improving the accuracy and generalization ability of the downstream belt damage detection model. It is especially suitable for online monitoring of belt conveyors in complex environments such as coal mines and ports.

[0017] 3. A system adapted to this method is provided, which not only improves the practicality of this method, but also facilitates its promotion. Attached Figure Description

[0018] To more clearly illustrate the technical solutions of the embodiments of this application, the accompanying drawings used in the embodiments will be briefly introduced below. It should be understood that the following drawings only show some embodiments of this application and should not be regarded as a limitation of the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is a schematic flowchart of a sample generation method for longitudinal tear detection of belts according to an embodiment of the present invention. Figure 2 This is a schematic diagram of the laser lines on the belt surface when it is normal, according to an embodiment of the present invention. Figure 3 This is a schematic diagram of the laser lines when a longitudinal tear occurs on the surface of the belt according to an embodiment of the present invention; Figure 4 This is a schematic diagram of the framework of a sample generation system for detecting longitudinal tearing of belts according to an embodiment of the present invention. Detailed Implementation

[0020] Specific embodiments of the present invention will now be described in detail. It should be noted that the embodiments described herein are for illustrative purposes only and are not intended to limit the invention. In the following description, numerous specific details are set forth in order to provide a thorough understanding of the invention. However, it will be apparent to those skilled in the art that these specific details are not necessary to practice the invention. In other instances, well-known circuits, software, or methods have not been specifically described to avoid obscuring the invention.

[0021] Throughout this specification, references to "an embodiment," "an embodiment," "an example," or "an example" mean that a particular feature, structure, or characteristic described in connection with that embodiment or example is included in at least one embodiment of the invention. Therefore, the phrases "in an embodiment," "in an embodiment," "an example," or "an example" appearing in various places throughout the specification do not necessarily refer to the same embodiment or example. Furthermore, specific features, structures, or characteristics can be combined in one or more embodiments or examples in any suitable combination and / or sub-combination. Moreover, those skilled in the art will understand that the illustrations provided herein are for illustrative purposes and are not necessarily drawn to scale.

[0022] It should be noted in advance that, in one alternative embodiment, apart from being described independently, the same symbols or letters appearing in all formulas have the same meaning and value.

[0023] In one optional embodiment, please refer to Figure 1 This invention provides a sample generation method for detecting longitudinal tearing of belts, the method comprising the following steps: S1. Obtain real samples of the belt under normal conditions and when there is longitudinal tear, in order to build a sample dataset and an anomaly patch library.

[0024] Specifically, in this embodiment, belt damage detection based on laser scanning technology has the following two significant advantages: 1. High precision: Laser scanning can very accurately capture minute changes on the belt surface. Even extremely small cracks, holes, or wear marks cannot escape its detection, allowing for detailed and accurate acquisition of various characteristic information about belt damage. 2. Non-contact: Laser scanning technology can complete the detection work without direct contact with the belt surface. This avoids secondary damage to the belt caused by contact, and also makes the detection process more convenient and efficient, without affecting the normal operation of the belt conveyor. Based on these advantages, laser scanning technology is widely used to extract belt damage characteristics, helping people understand the health status of belts.

[0025] In this embodiment, a line laser is first vertically projected onto the surface of the running belt. A high-speed industrial camera performs real-time image acquisition of the vertically projected line laser onto the belt surface with an exposure time of 200 microseconds, a gain of 8x, and a frame rate of 500 frames per second, thereby obtaining a laser stripe image.

[0026] When the belt surface is normal, the corresponding laser stripe image is binarized to obtain the laser lines as shown. Figure 2 As shown, the laser line is often affected by environmental factors such as oil stains, water stains, and light spots on the belt surface, leading to blurred damage edge features and affecting detection accuracy. When there are oil stains or water stains on the belt surface, the laser line will be unevenly bright; when light spots appear on the belt surface, some spots may overlap with the laser line; when noise is present, isolated, random small bright spots will appear around the laser line or in the background. To improve detection accuracy, image preprocessing can be performed. However, traditional denoising, filtering, and image enhancement methods can usually only deal with some simple and obvious interference factors. For complex and variable environmental interference, such as different types and degrees of oil stains, water stains, and randomly appearing light spots, it is difficult to achieve comprehensive and accurate removal. Moreover, preprocessing methods are often fixed and static, and cannot be dynamically adjusted according to the actual distribution and changes of the data.

[0027] When a longitudinal tear occurs on the belt surface, the corresponding laser stripe image is binarized, and the laser lines appear as follows: Figure 3As shown, by collecting laser line images of different belt tears to construct a dataset, a belt recognition model can be built using traditional machine learning algorithms such as convolutional neural networks to identify belt tears and their types. However, belt tear samples are rare during normal operation, making it difficult to collect enough data to train the algorithm, resulting in a severe shortage of training data. Furthermore, traditional preprocessing methods struggle to effectively eliminate the negative impact of environmental factors on belt damage detection, leading to a weak adaptability and poor robustness of the trained belt recognition model to complex environments. Therefore, the following section will construct a sample generation network to obtain a sample generation model, generating a sufficient number of laser line images under different environmental influences to address the aforementioned problems.

[0028] More specifically, laser stripe images of belts under longitudinal tears are acquired using laser scanning technology. Simultaneously, laser stripe images of belts under normal conditions (without longitudinal tears) are also acquired. For the laser stripe images under normal conditions, they are directly used as real samples, labeled "0," and stored in a folder named "normal." For the laser stripe images under longitudinal tears, images exhibiting only single environmental interference are selected as real samples, labeled "1," and then stored in folders named "abnormal1," "abnormal2," and "abnormal3" respectively, categorized by environmental interference type: oil stains, water stains, and light spots.

[0029] For all real samples in abnormal1, abnormal2, abnormal3, and normal, the following standardization process is performed using OpenCV tools: Read the real samples using OpenCV's `imread` function, forcibly specifying the `IMREAD_GRAYSCALE` mode to convert them into grayscale images; call the `cv2.resize` function, employing bilinear interpolation to forcibly stretch or compress the grayscale image to a fixed size of 128 pixels high and 512 pixels wide, achieving grayscale image scaling; execute `cv2.threshold` on the scaled grayscale image, setting the threshold to 20 and the mode to `THRESH_BINARY`, converting the grayscale image into a black-and-white binary image, where the background pixel value is 0 and the laser stripe pixel value is 255; for each pixel in the black-and-white binary image, divide its pixel value by 255, convert the data type to float32 floating-point number to normalize the black-and-white binary image, and then call `np.expand_dims` to expand the original shape (128, ... The binary image (512) is transformed into a 3D tensor of shape (128, 512, 1) by adding a dimension at the last position, where the "1" represents the number of channels. The 3D tensor corresponding to each real sample is placed into one Python list, and its corresponding label (0 or 1) is placed into another list. `np.concatenate` is then called along the 0th dimension (i.e., the dimension of the number of real samples). Further, a sample dataset is constructed using all the 3D tensors, with each 3D tensor representing a training sample in the dataset.

[0030] For any real sample with environmental interference, an anomaly patch library is built based on OpenCV and the Computer Vision Pipeline (CV Pipeline). The specific steps are as follows.

[0031] First, after obtaining the grayscale image of the real sample, for each pixel of the image, its pixel value is divided by 255 to obtain a normalized grayscale image. Each pixel in the normalized grayscale image is iterated through; if its grayscale value is greater than 0.07, it is directly converted to white; otherwise, it is directly converted to black, resulting in a binary image. Then, based on the Zhang-Suen algorithm, a skeletonization operation is performed on this binary image, thinning the wide laser lines into single-pixel-width center lines to eliminate the interference of line width on geometric measurements, resulting in a single-pixel-width skeleton. A cubic spline function (Univariate Spline, order k=3) is used to perform curve fitting on the skeleton points on the single-pixel-width skeleton, and two spline curves with different smoothness levels are generated according to different values ​​of the smoothing parameter s: one is a loose spline (s = number of skeleton points × 0.5, closely fitting the local undulations of the actual skeleton to preserve the true shape of the curve), and the other is a tight spline (s = number of skeleton points × 3.0, highly smooth, reflecting only the overall trend of the curve while ignoring local fluctuations).

[0032] By utilizing the derivative property of cubic splines, the second derivative of the loose spline object is directly calculated. Then, the pixel coordinates (x, y) corresponding to each skeleton point are substituted into the second derivative to obtain the original curvature value at that skeleton point. The curvature values ​​of all skeleton points are arranged in ascending order of their column coordinates in the pixel coordinate system, forming the original curvature sequence. Here, x represents the column number of the skeleton point in the binary image containing the single-pixel wide skeleton, y represents the row number of the skeleton point in the binary image containing the single-pixel wide skeleton, and the origin of the pixel coordinate system is located at the first pixel point at the bottom left corner of the binary image containing the single-pixel wide skeleton.

[0033] Furthermore, a Gaussian kernel with a standard deviation of 2.0 (window size of 12 or 16) is used to perform convolution filtering on the original curvature sequence along the X-axis of the pixel coordinate system, and the maximum-minimum normalization method is used to numerically normalize the filtered original curvature sequence to obtain the centerline curvature vector of the single-pixel wide skeleton.

[0034] Next, anomaly detection is performed. Anomaly detection is divided into a bump anomaly detection stage and a gap anomaly detection stage. In the bump anomaly detection stage, the pipeline scans the skeleton points column by column along the horizontal direction, and calculates the absolute value of the difference between the ordinate of each skeleton point and the ordinate of the corresponding position of the tight spline as the deviation value. When the deviation value exceeds 3 pixels, the point is identified as an anomaly candidate point. Subsequently, a circular marker is drawn with each anomaly candidate point as the center and a radius of max(3, deviation value × 1.5) to roughly define the distribution range of the anomaly region. In order to connect the adjacent isolated circular markers into a complete anomaly region, a morphological closing operation is performed using a 3×3 structuring element (with 2 iterations) to connect adjacent circular markers into a unified candidate connected region. Then, each connected region is extracted through connected components analysis, and small noise regions with an area of ​​less than 10 pixels are filtered out. The remaining connected regions are the final bump anomaly regions. Each region is extracted as an independent image patch in the form of a bounding box, which serves as a bump patch.

[0035] During the gap anomaly detection phase, the pipeline detects skeleton endpoints using a 3×3 convolution kernel. The specific criterion is that the sum of the number of skeleton points in the 8-neighborhood of a pixel equals 2, meaning there is only one adjacent skeleton point, thus identifying all endpoints. After obtaining all endpoints, normal endpoints located at the leftmost and rightmost edges of the image (i.e., the physical start and end points of the laser line) are excluded, and the remaining internal endpoints are considered as potential break endpoints. When the total number of detected internal endpoints is greater than or equal to 4, it indicates that there are at least two breaks in the laser line. At this point, a break pairing mechanism is activated, pairing two endpoints with a horizontal spacing of less than 20 pixels and a vertical spacing of less than 12 pixels into a gap group, and drawing a 5-pixel wide straight line between these endpoints to mark the crack area. This area is also extracted as an independent image patch.

[0036] Bump patches and gap patches are categorized and stored to obtain bump sub-libraries and gap sub-libraries. At the same time, the corresponding binary images of single-pixel wide skeletons, centerline curvature vectors, and endpoint pixel coordinates are also stored in the corresponding sub-libraries. The final exception patch library is composed of the bump sub-library and the gap sub-library.

[0037] It should be noted that the skeleton extraction and spline fitting methods used in this embodiment are based on mature algorithms in existing literature, and their core algorithms have not been modified. The contribution of this invention is only to adapt key parameters such as binarization threshold, deviation detection threshold, endpoint pairing distance and minimum connected area to the image characteristics of thin laser lines and a size of 128×512 in the local sample. This allows the invention to effectively eliminate false alarms introduced by environmental noise while maintaining high detection accuracy, thereby providing geometrically accurate and physically realistic material sources for subsequent abnormal patch stitching.

[0038] S2. Construct a sample generation network based on feature-decoupled autoencoders and generative adversarial networks.

[0039] Specifically, in this embodiment, the sample generation network includes a Feature Disentangled Auto-Encoder (FD-AE) and a Discriminator (D). The Feature Disentangled Auto-Encoder includes an encoder (E) and a decoder (De), and the Discriminator includes a data discriminator and two potential discriminators.

[0040] The encoder takes a real sample as input and maps it to two independent latent variable distribution parameter vectors. It generates two decoupled latent features through random sampling. These latent features include a core feature z1 (laser line feature) and a redundant feature z2 (water stain, oil stain, or light pollution feature). The decoder takes the latent features output from the encoder and the skip connection output as input to reconstruct the real sample, obtaining a reconstructed image. The data discriminator takes either a real sample or the reconstructed image as input and outputs a realism score for the reconstructed image. The first latent variable discriminator takes the core feature z1 and a prior latent variable z10 sampled from a standard normal prior distribution as input, and outputs a feature realism probability (i.e., how closely the core feature z1 approximates the standard normal prior, ranging from 0 to 1). The second latent variable discriminator takes the redundant feature z2 and a prior latent variable z20 sampled from a standard normal prior distribution as input, and outputs a feature realism probability (i.e., how closely the redundant feature z2 approximates the standard normal prior).

[0041] The encoder has an input dimension of (128, 512, 1) and uses 5 coding layers to downsample the real samples step by step. Each coding layer consists of only a single-layer convolution and activation function to extract the distribution parameters of latent variables and skip connection features.

[0042] The first coding layer uses 64 4×4 convolutional kernels with a stride of 2, and the output feature map size is (64, 256, 64). This output is also used as the reserved feature map for skip connections. The second coding layer uses 128 4×4 convolutional kernels with a stride of 2, and the output feature map size is (32, 128, 128). The third coding layer uses 256 3×3 convolutional kernels with a stride of 1, and the output feature map size is (32, 128, 256). This feature map is only used for internal transmission and is not output externally. The fourth coding layer uses 256 4×4 convolutional kernels with a stride of 2, and the output feature map size is (16, 64, 256). The fifth coding layer uses 128 1×1 convolutional kernels with a stride of 1, and the output feature map size is (16, 64, 128). All convolutional layers of the encoders use the same padding and are activated by LeakyReLU(0.2) after convolution.

[0043] Subsequently, the output of the fifth encoding layer is flattened into a one-dimensional feature vector of dimension 131072, and then sequentially connected to two fully connected layers. The first fully connected layer outputs a core feature latent variable mean vector of dimension 192 and a redundant feature latent variable mean vector of dimension 64. The second fully connected layer outputs a core feature latent variable log-variance vector of dimension 192 and a redundant feature latent variable log-variance vector of dimension 64.

[0044] Finally, a 192-dimensional vector is randomly sampled from the distribution determined by the mean vector and the log-variance vector of the core feature latent variables using the reparameterization technique, which serves as the core feature z1. At the same time, a 64-dimensional vector is randomly sampled from the mean vector and the log-variance vector of the redundant feature latent variables using the same reparameterization technique, which serves as the redundant feature z2.

[0045] The decoder takes as input a core feature z1, a redundant feature z2, and a preserved feature map of size (64, 256, 64), and includes one basal layer, three decoding layers, and one feature fusion layer. Specifically, the decoder first concatenates the core feature z1 and the redundant feature z2 into a 256-dimensional latent variable z. A fully connected layer maps the latent variable z to a feature map of size (16, 64, 256). Then, a convolutional layer with 256 3×3 convolutional kernels and batch normalization (BN) is used to process this feature map. After applying the LeakyReLU(0.2) activation function, a feature map of size (16, 64, 256) is obtained.

[0046] Subsequently, the first decoding layer first upsamples the output of the base layer by a factor of 2 (UpSampling2D), then processes the upsampled result using a convolutional layer with 256 kernels of size 3×3 and the same padding. The convolutional output is then sequentially applied to the LeakyReLU (0.2) activation function, ultimately obtaining a feature map of size (32, 128, 256). The second decoding layer first upsamples the feature map output from the first decoding layer by a factor of 2, then processes the upsampled result using a convolutional layer with 128 kernels of size 3×3 and the same padding. The convolutional output is then sequentially applied to the LeakyReLU activation function. The (0.2) activation function is used to obtain a feature map with a size of (64,256,128). The feature fusion layer concatenates the aforementioned preserved feature map with the feature map output by the second decoding layer in the channel dimension to obtain a fused feature map with a size of (64,256,192). Then, a convolutional layer with 128 kernels of size 3×3 and the same padding is used to process the fused feature map. After the convolution output, it is serially connected to the LeakyReLU(0.2) activation function to obtain a feature map with a size of (64,256,128). The third decoding layer first performs a 2x upsampling operation on the feature map output by the feature fusion layer. Then, a convolutional layer with 64 kernels of size 3×3 and the same padding is used to process the upsampling result. After the convolution output, it is serially connected to the LeakyReLU(0.2) activation function to obtain a feature map with a size of (128,512,64).

[0047] Finally, a reconstructed image is output by passing it through a convolutional layer with a 3×3 kernel and the same padding, and then activating it with the Sigmoid function. The image size is restored to (128, 512, 1).

[0048] The data discriminator has an input dimension of (128, 512, 1) and consists of four convolutional layers and one output layer. The first convolutional layer uses 32 4×4 kernels and outputs a feature map of size (64, 256, 64); the second uses 64 4×4 kernels and outputs a feature map of size (32, 128, 128); the third uses 128 4×4 kernels and outputs a feature map of size (16, 64, 256); and the fourth uses 256 4×4 kernels and outputs a feature map of size (8, 32, 512). The feature map output from the fourth convolutional layer is flattened into a one-dimensional vector and input into a fully connected layer, where it is mapped to a one-dimensional output (without an activation function). This output represents the realism probability; a higher realism probability indicates that the reconstructed image is closer to the real sample. In addition, each convolutional layer has a stride of 2 and uses the same padding, and is activated by LeakyReLU(0.2) after convolution.

[0049] Both latent variable discriminators consist of four sequential fully connected layers. The first three fully connected layers have 128, 64, and 32 neurons, respectively, each connected to a LeakyReLU (0.2) activation function. The final fully connected layer has only one neuron and no activation function; its output is the feature authenticity probability. It is important to emphasize that although the two latent variable discriminators have the same structure, their trainable parameters (i.e., the weight matrix and bias terms) are completely independent, without sharing or interfering with each other.

[0050] S3. Train the sample generation network using the sample dataset, optimize the network through a hierarchical joint loss function, so that the generated samples match the real distribution at both the data level and the feature level, and obtain the sample generation model.

[0051] Specifically, in this embodiment, the training process includes two consecutive stages: pre-training and adversarial training. In the pre-training stage, all training samples are first randomly shuffled and grouped into batches of 8. For each batch, the training samples are input into the encoder for forward propagation to obtain core features z1 and redundant features z2, while simultaneously extracting the retained feature map from the first layer convolution output of the encoder. The core features z1, redundant features z2, and the retained feature map are then input into the decoder to obtain the reconstructed image. Subsequently, the reconstruction loss and feature decoupling loss for this batch are calculated, and the sum of these two losses is used as the overall loss. After obtaining the overall loss, the gradients of each layer of the network are calculated through backpropagation, and the norm of the global gradient is clipped (threshold set to 5.0) to prevent gradient explosion caused by excessive early reconstruction errors. Then, the Adam optimizer is used to update the trainable parameters of the encoder and decoder, with an initial learning rate of 0.00001 and a decay coefficient of 0.5 for the first-order moment estimation. The above process is carried out in batches and iteratively. One iteration cycle (epoch) is completed after all training samples have been traversed once. In this embodiment, a total of 40 iteration cycles are preset. After each cycle, the overall loss on the validation set is calculated. At the same time, an early stopping mechanism is used for monitoring. If the change in the overall loss of the validation set does not exceed 0.00001 for 8 consecutive cycles, the training is terminated early, and the weight parameter that minimizes the overall loss is used as the final weight parameter of the feature decoupling autoencoder.

[0052] After pre-training, the sample dataset is divided into training and validation sets in a 7:3 ratio, and a data discriminator and a latent discriminator are introduced to initiate adversarial training. In each iteration of adversarial training, a game-theoretic mechanism of alternating optimization between the discriminator and decoder is adopted. First, all trainable parameters of the encoder and decoder are frozen. The reconstructed image output by the decoder and the real sample are input into the data discriminator, respectively. At the same time, the core feature z1, redundant feature z2, and sampled prior latent variables output by the encoder are input into the corresponding latent discriminator. The adversarial loss of the data discriminator and the adversarial loss of the latent discriminator are calculated and backpropagated to update the weight parameters of the three discriminators, aiming to improve the discriminator's ability to distinguish between real and fake distributions. Subsequently, the current weight parameters of the data discriminator and the latent discriminator are frozen. The joint total loss of the sample generation network is calculated based on the same batch of samples and backpropagated to update the weight parameters of the encoder and decoder. The weight parameter updates of the three discriminators, encoder, and decoder are performed alternately in each training batch until the joint total loss on the validation set stabilizes and converges to a preset threshold. After training convergence, the decoder is used as the final sample generation model to receive randomly sampled core features z1 and redundant features z2 to generate reconstructed images. The data discriminator loss, latent discriminator loss, and joint total loss satisfy the following relationships:

[0053]

[0054]

[0055] in, For the total loss, To reconstruct the loss, For feature decoupling loss, The KL divergence corresponding to the core feature z1, Let z2 be the KL divergence corresponding to the redundant feature. , Calculation method reference The calculation method To help the data discriminator combat loss, To compensate for the loss in the decoder against the data discriminator, To mitigate losses in the potential discriminator, To compensate for the loss of the decoder against the potential discriminator, For feature matching loss, , , , and For trainable weights, N is the total number of pixels in the real sample. Let i be the pixel value of the i-th pixel in the real sample. To reconstruct the pixel value of the i-th pixel in the image, M is the dimension of the latent feature, M=256, and B is the batch size, B=8. The j-th dimension of the latent variable means vector is the mean of the latent variables in the core feature latent variable mean vector. For the log-variance vector of the core feature latent variables, the j-th dimension is the log-variance of the latent variable. For the i-th real sample, For the i-th generated sample, for and Random interpolation samples between , The coefficients are random mixing coefficients and , For the data discriminator to input The output result, For the data discriminator to input The output results, For the output of the data discriminator gradient, The gradient penalty coefficient is... , It is the L2 norm. The latent variables are extracted from the normal distribution determined by the latent variable mean vector (core feature latent variable mean vector or redundant feature latent variable mean vector) and the latent variable log-variance vector (core feature latent variable log-variance or redundant feature latent variable log-variance) of the i-th real sample. Let be the i-th prior latent variable directly sampled from the standard normal prior distribution. for and random interpolation between , For the potential discriminator to input The output results, For the potential discriminator to input The output results, For the output pair of the potential discriminator gradient, The output of the second convolutional layer in the data discriminator is the i-th real sample. The output of the second convolutional layer in the data discriminator is the i-th generated sample. The output of the third convolutional layer in the data discriminator is the i-th real sample. The output of the third convolutional layer in the data discriminator is the i-th generated sample. It is an L1 norm.

[0056] S4. Generate a large number of candidate samples through the trained sample generation model, and extract abnormal patches from the abnormal patch library and combine them with the candidate samples to obtain an enhanced sample set.

[0057] Specifically, in this embodiment, since the skip connection output from the decoder is obtained when the sample generation model is used alone, 30 belts are taken as training samples under normal conditions. These are then input into the encoder one by one, and the retained feature maps of the first encoding layer output are extracted to form a spatial structure prior dataset. Core features z1 and redundant features z2 are randomly sampled from a standard normal distribution and concatenated into a 256-dimensional latent variable. This latent variable is then combined with the retained features randomly selected from the spatial structure prior dataset. Figure 1 The model is generated from the input samples, and the reconstructed image output is used as the target sample.

[0058] After generating the target sample, the number (preferably 0-4) of anomaly patches (including bump and gap patches) to add to the target sample, and whether each anomaly is a bump or a gap, are determined independently and randomly. Next, the insertion position of the anomalies is determined: assuming the centerline curvature vector of the desired anomaly patch is R-dimensional; a skeleton point J is randomly selected on the single-pixel wide skeleton of the target sample, and the curvature values ​​of this skeleton point and the next R-1 skeleton points are obtained, thus obtaining the centerline curvature vector of the skeleton segment in the target sample containing R skeleton points starting from skeleton point J; the cosine similarity between the centerline curvature vector of each anomaly patch and the centerline curvature vector of the skeleton segment is calculated, and the anomaly patch corresponding to the minimum cosine similarity value is taken as the optimal anomaly patch; the optimal anomaly patch is inserted into the target sample to replace the skeleton segment, resulting in the enhanced sample. It should be noted that if multiple anomaly patches need to be inserted, skeleton segments that have already been replaced will not have other anomaly patches inserted.

[0059] Next, the best anomaly patch is stitched to the corresponding region of the target sample. Specifically, this refers to the region occupied by a skeleton segment containing R skeleton points, starting from skeleton point J. Specifically, if the best anomaly patch is a bump patch, its skeleton point coordinates are mapped to the center line of the single-pixel-wide skeleton of the target sample using an affine transformation. Then, the single-pixel-wide skeleton of the best anomaly patch is drawn onto the corresponding region of the target sample using the `cv2.polylines` function in OpenCV to replace the laser lines in that region. If the best anomaly patch is a gap patch, a strip-shaped region with a width of 5-8 pixels is directly erased in the corresponding region of the target sample to simulate the transition effect of a natural crack in a belt. It is important to note that if multiple anomaly patches need to be inserted, no further anomaly patches will be inserted into regions of the target sample that have already been modified.

[0060] After stitching, the original enhanced sample is obtained. The single-pixel-width skeleton of the original enhanced sample is then obtained, and randomly dilated using a 3×3 elliptical kernel. The resulting skeleton width is randomly selected within the range of 1 to 3 pixels, yielding an enhanced sample with a style consistent with the real laser line image. By obtaining a large number of different enhanced samples, an enhanced sample set can be constructed using these samples.

[0061] Specifically, a candidate sample is retained when both the authenticity probability output by the data discriminator and the feature authenticity probability output by the potential discriminator are not less than the corresponding thresholds. All retained candidate samples are used to form an enhanced sample set for longitudinal belt tears. This enhanced sample set can be used to train the downstream belt damage detection model, improving its accuracy and generalization ability.

[0062] It should be noted that in some cases, the actions described in the specification can be performed in different orders and still achieve the desired results. In this embodiment, the order of steps is given only to make the embodiment clearer and easier to explain, and not to limit it.

[0063] In one optional embodiment, please refer to Figure 4 To improve the practicality of this method and facilitate its promotion, the present invention also provides a sample generation system for longitudinal tear detection of belts. The sample generation system for longitudinal tear detection of belts includes: a data acquisition device 1, a data output device 2, a processor 3, and a storage device 4. The storage device 4 includes a computer-readable storage medium storing a computer program. The computer program includes program instructions, which, when executed by the processor 3, cause the processor 3 to implement the method described in steps S1 to S4.

[0064] In summary, this invention has at least the following beneficial effects: This method addresses the problems of insufficient sample quantity and poor feature robustness due to environmental interference when extracting belt damage features using traditional laser scanning. By integrating the structured latent space learning capability of VAE with the high-fidelity generation capability of GAN, a sample generation model is constructed. This sample generation model can generate a large number of high-quality and diverse laser damage feature samples, improving the accuracy and generalization ability of downstream belt damage detection models, and is particularly suitable for online monitoring of belt conveyors in complex environments such as coal mines and ports. Furthermore, a system adapted to this method is provided, which not only improves the practicality of this method but also facilitates its promotion.

[0065] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention, and they should all be covered within the scope of the claims and specification of the present invention.

Claims

1. A sample generation method for detecting longitudinal tearing of belts, characterized in that, Includes the following steps: We obtained real samples of the belt under normal conditions and when there was longitudinal tear, in order to build a sample dataset and an anomaly patch library; A sample generation network is constructed based on feature-decoupled autoencoders and generative adversarial networks; The sample generation network includes a feature decoupled autoencoder, a feature extractor, and a discriminator. The feature decoupled autoencoder includes an encoder and a decoder. The encoder is used to map the real sample into two independent latent variable distribution parameter vectors and generate two decoupled latent features through random sampling. The sample generation network is trained using the sample dataset, and the network is optimized by a hierarchical joint loss function so that the generated samples match the real distribution at both the data level and the feature level, thus obtaining the sample generation model. The hierarchical joint loss function satisfies the following relationship: in, For the total loss, The reconstruction loss of the autoencoder is used to decouple the features. For feature decoupling loss, For data discriminator loss, For potential discriminant loss, For feature matching loss, , , , and To dynamically adjust the weights, ; A large number of candidate samples are generated by the trained sample generation model, and abnormal patches are extracted from the abnormal patch library and combined with the candidate samples to obtain an enhanced sample set.

2. The sample generation method for longitudinal tear detection of belts according to claim 1, characterized in that: The encoder reconstructs the real sample using the latent features and the jump output from the encoder to obtain a reconstructed image.

3. The sample generation method for longitudinal tear detection of belts according to claim 2, characterized in that: The potential features include core features and redundant features.

4. The sample generation method for longitudinal tear detection of belts according to claim 3, characterized in that: The discriminator includes a data discriminator and two potential discriminators; the input of the data discriminator is the real sample or the reconstructed image, and the output is the authenticity score of the reconstructed image; the input of the potential discriminator is the latent feature and the corresponding prior latent variable sampled from the standard normal prior distribution, and the output is the feature authenticity probability.

5. The sample generation method for longitudinal tear detection of belts according to claim 1, characterized in that: The sample generation network is trained using the sample dataset, and the decoder is ultimately used as the sample generation model.

6. A sample generation system for detecting longitudinal tearing of belts, characterized in that, The sample generation system for longitudinal tear detection of belts includes: a data acquisition device, a data output device, a processor, and a storage device. The storage device includes a computer-readable storage medium storing a computer program. The computer program includes program instructions, which, when executed by the processor, cause the processor to implement the sample generation method for longitudinal tear detection of belts as described in any one of claims 1-5.

Images