Bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial network

Abstract

A bearing abnormality detection and fault diagnosis method based on a deep convolutional generative adversarial network belongs to the technical field of artificial intelligence identification of mechanical components, and can realize both abnormality detection of bearing components and classification of bearing fault categories. The network model disclosed by the application has corresponding improvements in structure, and realizes fusion of the abnormality detection and fault diagnosis functions of bearing components in function, can also use model generated data for data expansion, and achieves a high accuracy in abnormality detection and fault diagnosis.

Description

Technical Field

[0001] This invention discloses a bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks, belonging to the technical field of artificial intelligence recognition of mechanical components. Background Technology

[0002] With the continuous development of industrial technology, anomaly detection and fault diagnosis of engineering machinery and equipment have received widespread attention. Rolling bearings are used in almost all types of rotating machinery. The working environment of bearings is complex and variable, and the high-speed operation of machinery makes rolling bearings more prone to failure. Rolling bearings also suffer from problems such as excessive noise and interference in the original vibration signals, insufficient labeled samples, and load migration. To ensure reliable and stable equipment operation, timely detection of fault points and handling of faulty parts can prevent large-scale economic losses or even industrial accidents. Therefore, anomaly detection and fault diagnosis have become an important research area in the context of intelligent manufacturing.

[0003] Traditional bearing anomaly detection and fault diagnosis based on vibration signals often employ time-domain, frequency-domain, or time-frequency analysis methods. However, the vibration signals of bearing faults exhibit complex non-stationary time-varying characteristics. Traditional time-frequency analysis methods use relatively fixed time-frequency resolutions to process non-stationary signals, resulting in problems such as high computational load and unsatisfactory diagnostic accuracy.

[0004] In bearing anomaly detection, the aim is to reduce noise interference and extract efficient features for accurate anomaly detection. A Chinese paper, "Research on Fault Diagnosis of Wind Turbine Main Bearings Based on Generative Adversarial Networks," authored by Zhang Xiangguo, was published in 2021. It proposed combining autoencoders and soft thresholding to utilize frequency domain information obtained through Fast Fourier Transform for bearing anomaly detection. Increasingly, research utilizes artificial intelligence algorithms to perform a series of operations on original fault datasets, including feature extraction, fusion, and dimensionality reduction, ultimately achieving anomaly detection and fault diagnosis. However, in many practical applications, the large difference between the number of normal and fault samples leads to a severe imbalance in the training samples. Generative Adversarial Networks (GANs), due to their powerful data generation capabilities, excel in data augmentation and have become a major method for solving unsupervised and semi-supervised problems.

[0005] The Chinese paper "Research on Fault Diagnosis of Main Bearing of Wind Turbine Based on Generative Adversarial Network" improves the adaptability of Auxiliary Classification Generative Adversarial Network (ACGAN) by introducing gradient penalty and constructing an improved ACGAN framework. Its GANomaly model combines AE with GAN and infers anomalies by comparing the differences between the original data and the reconstructed data in a higher abstract space.

[0006] In bearing fault diagnosis, based on the diagnostic methods used, it can be divided into two main categories: fault diagnosis based on electrical signals and fault diagnosis based on vibration signals. The first category primarily involves analyzing the inherent correlation between fault current and fault vibration signals, and then using the corresponding current characteristics to identify the bearing fault type. For example, the Chinese literature published in 2021 by Chai Zhihao of Henan University of Technology, titled "Research on Improved Rotor System Fault Diagnosis Method Based on Generative Adversarial Networks," uses time-frequency analysis for data preprocessing, converting one-dimensional time-series vibration signals into time-frequency images, which are then input into a convolutional neural network. This proposes a two-dimensional convolutional neural network fault diagnosis model and a two-dimensional convolutional neural network fault diagnosis method based on generated data. Experiments have verified the feasibility of identifying bearing faults using stator current characteristics. However, numerous experimental studies have shown that achieving efficient fault diagnosis using current signals is more difficult than using vibration signals. The second category involves fault diagnosis based on the bearing's vibration state.

[0007] Published in Measurement in 2022, the paper "A conditional variational autoencoding generative adversarial networks with self-modulation for rolling bearing fault diagnosis" by Liu Yunpeng et al. constructs a new model that integrates conditional variational autoencoders, conditional Wasserstein generative adversarial networks, and self-modulation to augment the data into a balanced dataset. Addressing the problem that one-dimensional mechanical vibration signals cannot adequately extract relative positional relationships when input into convolutional neural networks, a bearing fault diagnosis and classification method based on Gram angle field (GAF) and small-size convolutional capsule networks is proposed.

[0008] Rolling bearings are used in almost all rotating machinery. Bearing failures have a wide impact and high maintenance costs; therefore, accurate and rapid anomaly detection and fault classification are effective measures to improve the economic efficiency of mechanical equipment. However, rolling bearings suffer from problems such as excessive noise and interference in the original vibration signals, insufficient labeled samples, and load migration, resulting in a low proportion of bearing fault samples among various faults. This poses a challenge to network models based on large amounts of training data.

[0009] In summary, while existing technologies have yielded some research results in bearing anomaly detection and bearing fault diagnosis, no network model can simultaneously perform both. Furthermore, the accuracy of both anomaly detection and fault diagnosis is not particularly high. Therefore, this technical field urgently needs a model that can perform both bearing anomaly detection and bearing fault diagnosis and classification. This model should leverage the powerful data generation capabilities of generative adversarial networks (GANs) to generate data, which can then be used to augment the original dataset, thereby improving the accuracy of anomaly detection and fault diagnosis. Summary of the Invention

[0010] To address the problems of existing technologies, this invention discloses a bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks. A DC-GANomaly anomaly detection and fault diagnosis network model is constructed to achieve accurate and efficient anomaly detection and fault diagnosis of bearing data.

[0011] The detailed technical content of this invention is as follows:

[0012] A bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks, characterized by comprising:

[0013] (1) Construct a model based on deep convolutional generative adversarial networks

[0014] A deep convolutional network model, DC-GANomaly, composed of CNN and generative adversarial network is constructed, which combines the features of GANomaly and CGAN. An auxiliary classifier consisting of four fully connected layers is added to the discriminator for fault category classification. This design uses the trained model to generate realistic data for data augmentation and to train the classifier. The loss function is optimized to achieve bearing fault diagnosis. Together with the above, it is a supervised fault classification model.

[0015] (2) Training the deep convolutional network model DC-GANomaly

[0016] In the anomaly detection training phase, the normal one-dimensional vibration signal of the input bearing and the manually labeled normal signal are used to train the model until the entire network model reaches Nash equilibrium, and the deep convolutional network model DC-GANomaly trained in the anomaly detection phase is obtained.

[0017] In the fault diagnosis training phase, the one-dimensional vibration signal of the input bearing fault and manually labeled fault categories are used to train the model until the entire model reaches Nash equilibrium. The deep convolutional network model DC-GANomaly is used to generate fault data and add it to the initial training set. The expanded training set is used to train the classifier until the loss function converges, and then the training stops, resulting in the classifier trained in the fault diagnosis phase.

[0018] (3) Bearing abnormality detection and fault diagnosis

[0019] The one-dimensional vibration signal of the bearing acquired in real time is input into the DC-GANomaly deep convolutional network model trained in the anomaly detection stage to obtain the detection result of whether an anomaly has occurred.

[0020] The abnormal detection results are then input into the classifier trained in the fault diagnosis stage, which outputs the corresponding fault category label.

[0021] According to a preferred embodiment of the present invention, the deep convolutional network model DC-GANomaly includes: a generator, a sample generator, an encoder, and a discriminator;

[0022] The generator is a bowtie convolutional autoencoder neural network architecture; an auxiliary classifier consisting of four fully connected layers is added after the discriminator for bearing fault diagnosis. This design, based on the original GANomaly network framework, uses a bowtie convolutional autoencoder and a DCGAN convolutional neural network architecture as the main network structure, and adds an auxiliary classifier consisting of four fully connected layers after the discriminator for fault diagnosis. The deep convolutional network model DC-GANomaly is as follows: Figure 1 As shown, the deep convolutional network model DC-GANomaly can both detect anomalies in bearing data and classify bearing fault categories. It also enhances the training set with GAN-generated data, supplementing imbalanced sample sets and improving bearing fault diagnosis accuracy. The generator of the DC-GANomaly model has two inputs: a real sample and the corresponding fault category label. The generated sample is then compared with normal one-dimensional vibration signal data by an encoder. The comparison is performed with a set threshold to detect anomalies. The discriminator outputs a bearing fault classification diagnosis result, and the threshold is set according to the scenario; anomalies are determined when the value exceeds the threshold.

[0023] According to a preferred embodiment of the present invention, the DC-GANomaly deep convolutional network model trained during the anomaly detection phase specifically includes:

[0024] The original one-dimensional vibration signal of all normal data After wavelet transform, it is converted into a 1*32*32 time-frequency image sample. The time-frequency graph with embedded human-labeled normal tags is input into the generator, mapped to a low-dimensional reconstruction graph, and the generator produces new samples. Generate corresponding manually labeled normal and abnormal tags.

[0025] New sample Marked as 0, and time-frequency plot samples It is marked as category label 1;

[0026] Then, the sample combination is loaded, and its authenticity is identified and classified. That is, the time-frequency map sample and the new sample are input together into the discriminator, and the discriminator determines whether the sample is the real original sample or a new sample generated by the generator.

[0027] Subsequently, time-frequency graph samples Labels are denoted as l real New sample Labels are denoted as l fake The prediction of the time-frequency graph sample is denoted as p. real The prediction for the new sample is denoted as p. fake ;

[0028] The discriminator is trained by minimizing the loss function of the training model; the cross-entropy loss function of the discriminator is calculated using the following formula:

[0029] L d-real =f bce (p real , l real (I)

[0030] L a-fake =f bce (p fake , l fake (II)

[0031] L d =(L d-real +L d-fake )*0.5 (III)

[0032] In formulas (I), (II), and (III), L d-real The loss function f obtained after inputting time-frequency map samples into the discriminator, which compares the predicted labels and the true labels of the time-frequency map samples; bce Refers to the binary cross-entropy loss function; L d-fake The loss function between the predicted label of the generated sample and the generated label of the generated sample obtained after inputting a new sample into the discriminator; L d The cross-entropy loss function of the discriminator;

[0033] New sample The label is set to 1 and sent to the discriminator, which passes new samples with non-zero labels; by minimizing L... d To adjust and complete the training of the generator, that is, to minimize it by updating the gradient parameters in reverse; the features extracted by the discriminator from the original one-dimensional vibration signal are denoted as z. d-real The features extracted from the new sample by the discriminator are denoted as z.d-fake The bottleneck feature generated by the generator from the original one-dimensional vibration signal is denoted as z. g-raal The encoded features extracted from the new sample by the generator are denoted as z. g-fake The formula for calculating the cross-entropy loss function of the generator is as follows:

[0034] L adv =f adv (z d-real , z d-fake (IV)

[0035] L con =f con (x, x) fake (V)

[0036] L enc =f enc (z g-real , z g-fake (VI)

[0037] L g =w adv L adv +w con L con +w enc L enc (VII)

[0038] In formulas (IV), (V), (VI), and (VII), L adv f adv The feature matching loss is represented by calculating the L2 distance between the feature representations of the original one-dimensional vibration signal extracted by the discriminator and the feature representations of the new sample extracted by the discriminator. This reduces the instability of GAN training. The generator is updated based on the internal structure of the discriminator, i.e., the instability of GAN training is reduced by updating the gradient parameters and activation function in reverse. con f con To represent the context loss, calculate the L1 distance between the original one-dimensional vibration signal and the new sample; L enc f enc This represents the encoder loss, which minimizes the distance between the bottleneck features of the input and the encoded features extracted by the generator from the new sample.

[0039] The discriminator is used for: when the frequency map sample When input into the deep convolutional network model DC-GANomaly, it makes the output value predict p for time-frequency map samples. real To make the values ​​as close to 1 as possible, the network gradient parameters are updated based on the cross-entropy loss function, causing the loss function to converge more and more. This makes the discriminator's judgment of the sample closer and closer to 1. When a new sample is input... At that time, the discriminator attempts to make the prediction p of the time-frequency map samples... real By getting as close to 0 as possible, updating the network gradient parameters based on the cross-entropy loss function makes the loss function converge more and more, which can attempt to make a more accurate judgment, that is, to determine whether the new sample data is false; at the same time, it makes the prediction p of the time-frequency map samples more accurate. real The generator should be as close to 1 as possible, where a threshold is set to score the feature distance. If the distance is greater than the threshold, the output is 1, and if it is less than or equal to the threshold, the output is 0, so that the generator can successfully pass the discriminator.

[0040] A zero-sum game occurs between the discriminator and the generator, where the optimization objective is transformed into a minimax problem; the discriminator and generator are rotated sequentially during training to be optimized: first, the generator is fixed, and then the discriminator is optimized to maximize diagnostic accuracy; next, in reverse order, the discriminator is fixed, and then the generator is optimized; this process is repeated until the discriminator and generator reach Nash equilibrium, completing the training of DC-GANomaly.

[0041] According to a preferred embodiment of the present invention, the specific method for diagnosing bearing faults in step (3) includes:

[0042] All bearing fault original one-dimensional vibration signals After wavelet transform, the data is converted into a 1*32*32 time-frequency graph. Time-frequency graph samples with manually labeled fault categories are input into the generator and mapped to a low-dimensional reconstructed graph. The new samples are then used to generate the final graph. Generate corresponding category labels

[0043] New sample Marked as 0, and time-frequency plot samples The sample is labeled as category label 1, and then the sample combination is loaded to identify and classify its authenticity. That is, the time-frequency map sample and the new sample are input together into the discriminator, and the discriminator determines whether the sample is the real original sample or a new sample generated by the generator.

[0044] The discriminator is trained by minimizing the loss function of the training model. The formula for calculating the cross-entropy loss function of the discriminator is as follows:

[0045] L d =f bce (p real , l real (X)

[0046] In formula (IX), f bce Ld refers to the binary cross-entropy loss function; Ld refers to the discriminator's loss function.

[0047] The label is set to 1 and sent to the discriminator. The discriminator cannot pass the newly generated sample with a real label of 0. The generator is trained by minimizing Ld. The network gradient parameters are updated based on the cross-entropy loss function, making the loss function converge. This minimizes Ld. The formula for calculating the cross-entropy loss function of the generator in the deep convolutional network model DC-GANomaly is as follows:

[0048] L g =f adv (z d-real , z d-fake (XI)

[0049] In formula (XI), L g f adv The feature matching loss is represented by the L2 distance between the original one-dimensional vibration signal and the feature representation of the new sample after processing by the discriminator; the features extracted from the original one-dimensional vibration signal by the discriminator are denoted as z. d-real The features extracted from the new sample by the discriminator are denoted as z. d-fake ;

[0050] The discriminator is used for: when the frequency map sample When input into the deep convolutional network model DC-GANomaly, it makes the output value predict p for time-frequency map samples. real To make the values ​​as close to 1 as possible, the network gradient parameters are updated based on the cross-entropy loss function, causing the loss function to converge more and more. This makes the discriminator's judgment of the sample closer and closer to 1. When a new sample is input... At that time, the discriminator attempts to make the prediction p of the time-frequency map samples... real By getting as close to 0 as possible, updating the network gradient parameters based on the cross-entropy loss function makes the loss function converge more and more, which can attempt to make a more accurate judgment, that is, to determine whether the new sample data is false; at the same time, it makes the prediction p of the time-frequency map samples more accurate. real The generator should be as close to 1 as possible, where a threshold is set to score the feature distance. If the distance is greater than the threshold, the output is 1, and if it is less than or equal to the threshold, the output is 0, so that the generator can successfully pass the discriminator.

[0051] A zero-sum game occurs between the discriminator and the generator, where the optimization objective is transformed into a minimax problem; the discriminator and generator are rotated sequentially during training to be optimized: first, the generator is fixed, and then the discriminator is optimized to maximize diagnostic accuracy; next, in reverse order, the discriminator is fixed, and then the generator is optimized; this process is repeated until the discriminator and generator reach Nash equilibrium, completing the training of DC-GANomaly.

[0052] According to a preferred embodiment of the present invention, in step (2), the augmentation method corresponding to the augmented training set includes:

[0053] After the deep convolutional network model DC-GANomaly is trained, the generator generates bearing vibration signal data of different fault types according to the given labels to augment the original unbalanced sample set, thereby achieving data augmentation. The augmented dataset is denoted as [database name missing]. The expanded data label is denoted as l ehance The classification labels generated by the classifier are denoted as l. c .

[0054] According to a preferred embodiment of the present invention, the method for training the classifier using the expanded training set in step (2) includes:

[0055] Train the classifier using an augmented balanced sample set, such as Figure 5 As shown;

[0056] The formula for calculating the cross-wrap loss function of the classifier is as follows:

[0057] L c =f crossentropyloss l enhance , l c (XII)

[0058] In formula (XII), L c f crossentropyloss This refers to the multi-class cross-entropy loss function.

[0059] After offline data augmentation, the problem of data imbalance can be resolved, thereby improving the accuracy of fault diagnosis. During the fault diagnosis testing phase, the classifier trained in the offline data augmentation phase can be directly used to generate accurate and rapid diagnostic results from the bearing fault data as output. Fault diagnosis is as follows: Figure 3 , Figure 4 .

[0060] Beneficial technical effects of the present invention:

[0061] The bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks described in this invention can both detect anomalies in bearing components and classify bearing fault categories.

[0062] When using this invention for anomaly detection, the model is trained using a time-frequency graph converted from the collected normal bearing vibration signal. The model then learns the characteristic distribution of the normal bearing vibration signal data. During the testing phase, both normal and abnormal bearing vibration data are input. The model extracts the characteristic distribution of the learned data. Through a bowtie autoencoder and decoder, the model reduces noise interference in the data and better learns the vibration distribution. The characteristic distribution of the tested data is compared with the characteristic distribution of the normal data learned during training; if it exceeds a set threshold, an anomaly is considered to have occurred.

[0063] Following anomaly detection, the fault diagnosis phase begins: the bearing fault dataset is input into the model for training. After the generator and discriminator are trained alternately until they reach Nash equilibrium, the trained model generates fault data. The generated data has a strong similarity to the original data and is added to the training set for data augmentation. The discriminator is then retrained using the augmented dataset. During the testing phase, the fault data is input into the discriminator, and the last linear layer of the auxiliary classifier classifies the fault data as the output result.

[0064] The network model described in this invention has been improved in structure and has integrated the functions of anomaly detection and fault diagnosis for bearing components. It can also use model-generated data for data expansion and has achieved a high accuracy rate in anomaly detection and fault diagnosis. Attached Figure Description

[0065] Figure 1 This is a framework diagram of the DC-GANomaly deep convolutional network model of this invention;

[0066] Figure 2 yes Figure 1 Detailed network structure diagram;

[0067] exist Figure 2 In this model, the discriminator has both discrimination and classification functions; the general structure and hyperparameter selection of the deep convolutional network model DC-GANomaly are based on experimental results from the original GANomaly literature; the Adam algorithm is used to optimize the generator and discriminator of the deep convolutional network model DC-GANomaly.

[0068] exist Figure 2In this code, Net G refers to the generator; Net D refers to the discriminator; encoder and decoder are a pair of self-encoding and self-decoding machines; encoder1 is the anomaly detection auxiliary encoder, and encoder2 is the encoder in the discriminator; "anomaly detection" refers to the bearing anomaly detection based on the deep convolutional network model DC-GANomaly; "feature value" refers to the latent feature representation of the image through encoder2; "predicted label for data" refers to a 0-1 discriminant value that the discriminator assigns to the data during the anomaly detection stage to determine whether the data is real or generated data, thus completing the model training; "fault diagnosis" refers to the fault diagnosis results generated during classifier training and the fault diagnosis classification results generated after the classifier training is completed and the fault data is tested.

[0069] Figure 3 This is a schematic diagram of bearing anomaly detection in this invention;

[0070] exist Figure 3 In this context, Initial data refers to the original one-dimensional vibration signal; class refers to the normal category label; Generator refers to the generator; Discriminator refers to the discriminator; Convolution refers to the convolutional neural network; ReLU refers to the activation function; Batchnorm refers to the normalization process; Auxiliary encoder refers to the auxiliary encoder for anomaly detection; Sigmoid refers to the binary classification activation function; Parameter sharing refers to parameter sharing; Anomaly detection refers to anomaly detection; Score refers to the score; Abnormal / normal refers to anomaly / normality.

[0071] Figure 4 This is a flowchart of the extended data in bearing fault diagnosis according to the present invention;

[0072] exist Figure 4 In this context, Initial data refers to the original one-dimensional vibration signal; class refers to the fault category label; Generator refers to the generator; Discriminator refers to the discriminator; Convolution refers to the convolutional neural network; ReLU refers to the activation function; Batchnorm refers to the normalization process; Sigmoid refers to the binary classification activation function; and Data enrichment refers to data augmentation.

[0073] Figure 5 This is a flowchart of the present invention for bearing fault diagnosis;

[0074] exist Figure 5In Chinese, Fault Diagnosis refers to fault diagnosis; Fault classifier refers to fault classification; Convolution refers to a convolutional neural network; ReLU refers to an activation function; Flatten refers to a fully connected layer; Linear refers to a fully connected layer; and Diagnosis Results refers to diagnostic results.

[0075] Figure 6 This is a schematic diagram of the first stage of bearing anomaly detection using the method described in this invention, namely, training the model with a training set, alternately training the generator and discriminator, and after training is completed, using the model's generator to generate data and adding it to the training set;

[0076] Figure 7 This is a schematic diagram of bearing anomaly detection using the method described in this invention;

[0077] Figure 8 This is a schematic diagram of the second stage of bearing anomaly detection using the method described in this invention, namely, training the discriminator with a training set (original training data and generated data) and verifying it with a test set;

[0078] Figure 9 This is a schematic diagram of the bearing fault diagnosis process using the method described in this invention;

[0079] The bearing fault diagnosis process is divided into two stages, such as... Figure 4 , Figure 5 As shown: In the initial stage of iteration, the DC-GANomaly generator has a large loss, but it converges quickly thereafter, forming a Nash equilibrium with the discriminator loss; when the number of iterations approaches 50, the diagnostic accuracy reaches 99.375%;

[0080] Figure 10 A schematic diagram of the bearing anomaly detection process framework of this invention;

[0081] Figure 11 This is a diagram illustrating how increasing the accuracy of fault diagnosis improves the accuracy of fault data categories.

[0082] Figure 12 This is a graph showing the results of comparing the accuracy of the method described in this invention with that of other models. Detailed Implementation

[0083] The present invention will now be described in detail with reference to the embodiments and accompanying drawings, but is not limited thereto.

[0084] Example 1

[0085] A bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks includes:

[0086] (1) Construct a model based on deep convolutional generative adversarial networks

[0087] A deep convolutional network model, DC-GANomaly, composed of CNN and generative adversarial network is constructed, which combines the features of GANomaly and CGAN. An auxiliary classifier consisting of four fully connected layers is added to the discriminator for fault category classification. This design uses the trained model to generate realistic data for data augmentation and to train the classifier. The loss function is optimized to achieve bearing fault diagnosis. Together with the above, it is a supervised fault classification model.

[0088] (2) Training the deep convolutional network model DC-GANomaly

[0089] In the anomaly detection training phase, the normal one-dimensional vibration signal of the input bearing and the manually labeled normal signal are used to train the model until the entire network model reaches Nash equilibrium, and the deep convolutional network model DC-GANomaly trained in the anomaly detection phase is obtained.

[0090] In the fault diagnosis training phase, the one-dimensional vibration signal of the input bearing fault and manually labeled fault categories are used to train the model until the entire model reaches Nash equilibrium. The deep convolutional network model DC-GANomaly is used to generate fault data and add it to the initial training set. The expanded training set is used to train the classifier until the loss function converges, and then the training stops, resulting in the classifier trained in the fault diagnosis phase.

[0091] (3) Bearing abnormality detection and fault diagnosis

[0092] The one-dimensional vibration signal of the bearing acquired in real time is input into the DC-GANomaly deep convolutional network model trained in the anomaly detection stage to obtain the detection result of whether an anomaly has occurred.

[0093] The abnormal detection results are then input into the classifier trained in the fault diagnosis stage, which outputs the corresponding fault category label.

[0094] The deep convolutional network model DC-GANomaly includes: a generator, a sample generator, an encoder, and a discriminator;

[0095] The generator is a bowtie convolutional autoencoder neural network architecture; an auxiliary classifier consisting of four fully connected layers is added after the discriminator for bearing fault diagnosis. This design, based on the original GANomaly network framework, uses a bowtie convolutional autoencoder and a DCGAN convolutional neural network architecture as the main network structure, and adds an auxiliary classifier consisting of four fully connected layers after the discriminator for fault diagnosis. The deep convolutional network model DC-GANomaly is as follows: Figure 1As shown, the deep convolutional network model DC-GANomaly can both detect anomalies in bearing data and classify bearing fault categories. It also enhances the training set with GAN-generated data, supplementing imbalanced sample sets and improving bearing fault diagnosis accuracy. The generator of the DC-GANomaly model has two inputs: a real sample and the corresponding fault category label. The generated sample is then compared with normal one-dimensional vibration signal data by an encoder. The comparison is performed with a set threshold to detect anomalies. The discriminator outputs a bearing fault classification diagnosis result, and the threshold is set according to the scenario; anomalies are determined when the value exceeds the threshold.

[0096] The generator described herein is existing technology and includes a pair of bowtie autoencoders and decoders and an anomaly detection auxiliary encoder. The bowtie autoencoder has four convolutional layers, with batch normalization layers added after the two middle convolutional layers, and ReLU activation functions used after the first three layers. The bowtie autodecoder is basically symmetrical to the bowtie autoencoder, with tanh used as the activation function in the fourth layer. The anomaly detection auxiliary encoder also consists of four convolutional layers, with batch normalization layers and ReLU layers added after the two middle layers.

[0097] The discriminator includes an encoder and an auxiliary classifier. The discriminator is an improvement on the existing technology to diagnose and classify fault data. Specifically, an auxiliary classifier consisting of four fully connected layers is added to the discriminator.

[0098] The encoder has the same structure as the bow autoencoder, and sigmoid is used as the activation function for classification.

[0099] The auxiliary classifier consists of one Flatten layer and four linear layers, with the classification being performed by the last linear layer.

[0100] The DC-GANomaly deep convolutional network model trained during the anomaly detection phase specifically includes:

[0101] The original one-dimensional vibration signal of all normal data After wavelet transform, it is converted into a 1*32*32 time-frequency image sample. The time-frequency graph with embedded human-labeled normal tags is input into the generator, mapped to a low-dimensional reconstruction graph, and the generator produces new samples. Generate corresponding manually labeled normal and abnormal tags.

[0102] New sample Marked as 0, and time-frequency plot samples It is marked as category label 1;

[0103] Then, the sample combination is loaded, and its authenticity is identified and classified. That is, the time-frequency map sample and the new sample are input together into the discriminator, and the discriminator determines whether the sample is the real original sample or a new sample generated by the generator.

[0104] Subsequently, time-frequency graph samples Labels are denoted as l real New sample Labels are denoted as l fake The prediction of the time-frequency graph sample is denoted as p. real The prediction for the new sample is denoted as p. fake ;

[0105] The discriminator is trained by minimizing the loss function of the training model; the cross-entropy loss function of the discriminator is calculated using the following formula:

[0106] L d-real =f bce (p real , l real (I)

[0107] L d-fake =f bce (p fake , l fake (II)

[0108] L d =L d-real +L d-fake )*0.5 (III)

[0109] In formulas (I), (II), and (III), L d-real The loss function f obtained after inputting time-frequency map samples into the discriminator, which compares the predicted labels and the true labels of the time-frequency map samples; bce Refers to the binary cross-entropy loss function; L d-fake The loss function between the predicted label of the generated sample and the generated label of the generated sample obtained after inputting a new sample into the discriminator; L a The cross-entropy loss function of the discriminator;

[0110] New sample The label is set to 1 and sent to the discriminator, which passes new samples with non-zero labels; by minimizing L... d To adjust and complete the training of the generator, that is, to minimize it by updating the gradient parameters in reverse; the features extracted by the discriminator from the original one-dimensional vibration signal are denoted as z. d-read The features extracted from the new sample by the discriminator are denoted as z. d-fakeThe bottleneck feature generated by the generator from the original one-dimensional vibration signal is denoted as z. g-real The encoded features extracted from the new sample by the generator are denoted as z. g-fake The formula for calculating the cross-entropy loss function of the generator is as follows:

[0111] L adv =f adv (z d-real , z d-fake (IV)

[0112] L con =f con (x, x) fake (V)

[0113] L enc =f enc (z g-real , z g-fake (VI)

[0114] L g =w adv L adv +w con L con +w enc L enc (VII)

[0115] In formulas (IV), (V), (VI), and (VII), L adv f adv The feature matching loss is represented by calculating the L2 distance between the feature representations of the original one-dimensional vibration signal extracted by the discriminator and the feature representations of the new sample extracted by the discriminator. This reduces the instability of GAN training. The generator is updated based on the internal structure of the discriminator, i.e., the instability of GAN training is reduced by updating the gradient parameters and activation function in reverse. con f con To represent the context loss, calculate the L1 distance between the original one-dimensional vibration signal and the new sample; L enc f enc This represents the encoder loss, which minimizes the distance between the bottleneck features of the input and the encoded features extracted by the generator from the new sample.

[0116] The discriminator is used for: when the frequency map sample When input into the deep convolutional network model DC-GANomaly, it makes the output value predict p for time-frequency map samples. real To make the values ​​as close to 1 as possible, the network gradient parameters are updated based on the cross-entropy loss function, causing the loss function to converge more and more. This makes the discriminator's judgment of the sample closer and closer to 1. When a new sample is input... At that time, the discriminator attempts to make the prediction p of the time-frequency map samples... real By getting as close to 0 as possible, updating the network gradient parameters based on the cross-entropy loss function makes the loss function converge more and more, which can attempt to make a more accurate judgment, that is, to determine whether the new sample data is false; at the same time, it makes the prediction p of the time-frequency map samples more accurate. reat The feature distance is scored as close to 1 as possible, where a threshold is set to score the feature distance; values ​​greater than the threshold are output as 1, and values ​​less than or equal to the threshold are output as 0, so that the generator successfully passes the discriminator.

[0117] A zero-sum game occurs between the discriminator and the generator, where the optimization objective is transformed into a minimax problem; the discriminator and generator are rotated sequentially during training to be optimized: first, the generator is fixed, and then the discriminator is optimized to maximize diagnostic accuracy; next, in reverse order, the discriminator is fixed, and then the generator is optimized; this process is repeated until the discriminator and generator reach Nash equilibrium, completing the training of DC-GANomaly.

[0118] Example 2

[0119] As described in Example 1, a bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks includes the following specific method for bearing fault diagnosis in step (3):

[0120] All bearing fault original one-dimensional vibration signals After wavelet transform, the data is converted into a 1*32*32 time-frequency graph. Time-frequency graph samples with manually labeled fault categories are input into the generator and mapped to a low-dimensional reconstructed graph. The new samples are then used to generate the final graph. Generate corresponding category labels

[0121] New sample Marked as 0, and time-frequency plot samples The sample is labeled as category label 1, and then the sample combination is loaded to identify and classify its authenticity. That is, the time-frequency map sample and the new sample are input together into the discriminator, and the discriminator determines whether the sample is the real original sample or a new sample generated by the generator.

[0122] The discriminator is trained by minimizing the loss function of the training model. The formula for calculating the cross-entropy loss function of the discriminator is as follows:

[0123] L d =f bce (p real , l real (X)

[0124] In formula (IX), f bceLd refers to the binary cross-entropy loss function; Ld refers to the discriminator's loss function.

[0125] The label is set to 1 and sent to the discriminator. The discriminator cannot pass the newly generated sample with a real label of 0. The generator is trained by minimizing Ld. The network gradient parameters are updated based on the cross-entropy loss function, making the loss function converge. This minimizes Ld. The formula for calculating the cross-entropy loss function of the generator in the deep convolutional network model DC-GANomaly is as follows:

[0126] L g =f adv (z d-real , z d-fake (XI)

[0127] In formula (XI), L g f adv The feature matching loss is represented by the L2 distance between the original one-dimensional vibration signal and the feature representation of the new sample after processing by the discriminator; the features extracted from the original one-dimensional vibration signal by the discriminator are denoted as z. d-real The features extracted from the new sample by the discriminator are denoted as z. d-fake ;

[0128] The discriminator is used for: when the frequency map sample When input into the deep convolutional network model DC-GANomaly, it makes the output value predict p for time-frequency map samples. real To make the values ​​as close to 1 as possible, the network gradient parameters are updated based on the cross-entropy loss function, causing the loss function to converge more and more. This makes the discriminator's judgment of the sample closer and closer to 1. When a new sample is input... At that time, the discriminator attempts to make the prediction p of the time-frequency map samples... real By getting as close to 0 as possible, updating the network gradient parameters based on the cross-entropy loss function makes the loss function converge more and more, which can attempt to make a more accurate judgment, that is, to determine whether the new sample data is false; at the same time, it makes the prediction p of the time-frequency map samples more accurate. real The generator should be as close to 1 as possible, where a threshold is set to score the feature distance. If the distance is greater than the threshold, the output is 1, and if it is less than or equal to the threshold, the output is 0, so that the generator can successfully pass the discriminator.

[0129] A zero-sum game occurs between the discriminator and the generator, where the optimization objective is transformed into a minimax problem; the discriminator and generator are rotated sequentially during training to be optimized: first, the generator is fixed, and then the discriminator is optimized to maximize diagnostic accuracy; next, in reverse order, the discriminator is fixed, and then the generator is optimized; this process is repeated until the discriminator and generator reach Nash equilibrium, completing the training of DC-GANomaly.

[0130] Example 3

[0131] As described in Examples 1 and 2, in the bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks, in step (2), the augmentation method corresponding to the augmented training set includes:

[0132] After the deep convolutional network model DC-GANomaly is trained, the generator generates bearing vibration signal data of different fault types according to the given labels to augment the original unbalanced sample set, thereby achieving data augmentation. The augmented dataset is denoted as [database name missing]. The expanded data label is denoted as l enhance The classification labels generated by the classifier are denoted as l. c .

[0133] In step (2), the method of training the classifier using the augmented training set includes:

[0134] Train the classifier using an augmented balanced sample set, such as Figure 5 As shown;

[0135] The formula for calculating the cross-entropy loss function of the classifier is as follows:

[0136] L c =f crossentropyloss (l enhance , l c (XII)

[0137] In formula (XII), L c f crossentropyloss This refers to the multi-class cross-entropy loss function.

[0138] After offline data augmentation, the problem of data imbalance can be resolved, thereby improving the accuracy of fault diagnosis. During the fault diagnosis testing phase, the classifier trained in the offline data augmentation phase can be directly used to generate accurate and rapid diagnostic results from the bearing fault data as output. Fault diagnosis is as follows: Figure 4 , Figure 5 .

[0139] Based on the technical content described in the above embodiments, the following is a detailed explanation:

[0140] I. The bearing anomaly detection process employs an offline model training and online anomaly detection mode, as follows: Figure 10 As shown.

[0141] During the anomaly detection phase, the detection accuracy reached 92.6% when the number of iterations approached 45.

[0142] 1. Offline model training

[0143] The model parameters are iteratively updated based on the loss function. The model is trained using the Adam optimizer, with the learning rate for both the discriminator and generator set to 0.0002. In each training unit, the discriminator and generator are trained alternately, one after the other.

[0144] The training process can be divided into two steps:

[0145] (1) The original one-dimensional vibration signal in the normal training sample is converted into a time-frequency map through wavelet transform. The time-frequency map with embedded normal labels is input into the generator model to obtain a low-dimensional reconstruction map. The reconstruction map is mixed with the real sample data and sent to the discriminator for training. The loss value of the discriminator network is calculated based on its loss function, and the network parameters are updated using the Adam optimizer.

[0146] (2) After training the discriminator, the combined structure begins training. In this stage, the model keeps the discriminator network weights unchanged, calculates the loss value of the model generator according to the loss function, and updates the network parameters using the Adam optimizer. Before each update of the generator network parameters, the discriminator network parameters are updated first to improve the model training speed.

[0147] After training this combined structure, which means one epoch has ended, the model training process will restart. After a sufficient number of iterations, the discriminator and generator networks reach Nash equilibrium, and the model training is complete. At this point, the network model can detect whether the input vibration signal is abnormal.

[0148] 2. Online anomaly detection

[0149] After the offline training model is completed, the fault data images in the test set are input into the trained DC-GANomaly model. The anomaly reconstruction of the encoder leads to the anomaly detection auxiliary encoder obtaining anomaly feature vectors, which results in dissimilarity with the bottleneck feature vectors of the original input data. The judgment of whether an anomaly has occurred is obtained by minimizing the feature difference.

[0150] II. Based on the bearing fault diagnosis implementation process of this invention, an offline data augmentation and online fault diagnosis mode is adopted, such as... Figure 9 As shown.

[0151] During the fault diagnosis phase, the diagnostic accuracy reached 99.375% when the number of iterations approached 50.

[0152] 1. Offline data enhancement

[0153] The model parameters are iteratively updated based on the loss function. The model training uses the Adam optimizer, with the learning rate for both the discriminator and generator set to 0.0007. In each training unit, the discriminator and generator are trained alternately, one after the other. The training process can be divided into two steps:

[0154] (1) All original one-dimensional vibration signals (fault data only) are converted into time-frequency maps by wavelet transform. The time-frequency maps with embedded category labels are input into the generator model to obtain low-dimensional reconstruction maps. The reconstruction maps are mixed with real sample data and sent to the discriminator for training. The loss value of the discriminator network is calculated based on its loss function, and the network parameters are updated using the Adam optimizer.

[0155] (2) After training the discriminator, the combined structure begins training. In this stage, the model keeps the discriminator network weights unchanged, calculates the loss value of the model generator according to the loss function, and updates the network parameters using the Adam optimizer. Before each update of the generator network parameters, the discriminator network parameters are updated first to improve the model training speed.

[0156] After training this combined structure, which marks the end of one epoch, the model training process restarts. After a sufficient number of iterations, the discriminator and generator networks reach Nash equilibrium, and model training is complete. At this point, the generator can generate bearing vibration signal data for different fault types based on given labels. This generated data is used to augment the original imbalanced sample set, achieving data augmentation. Subsequently, the classifier is trained using the augmented balanced sample set.

[0157] 2. Online fault diagnosis

[0158] After offline data augmentation is completed, the problem of data imbalance can be resolved, thereby improving the accuracy of fault diagnosis. In the online fault diagnosis stage, the classifier trained in the offline data augmentation stage can be used directly to make accurate and fast diagnoses of bearing fault data.

[0159] 3. Case Analysis

[0160] The simulation hardware is an 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz 2.42GHz, 8GB of RAM, and a LAPTOP-QP4FBG28 with 462GB of storage. The improved network model is built based on the deep learning frameworks PyTorch and Keras.

[0161] 3.1 Experimental Sample Construction

[0162] (1) Construction of bearing anomaly detection experimental samples based on DC-GANomaly

[0163] To facilitate model training, the selected experimental samples were divided into two parts: a training set and a test set. The improved DC-GANomaly was trained using the training set, and the model was validated using the test set. The first three classes of normal experimental samples were selected as the training set, and the fourth class of normal experimental samples and the three classes of abnormal samples were selected as the test set. The epoch was set to 100, the batch size was set to 64, and the w adv w con w enc Set them to 1, 60, and 1 respectively.

[0164] (2) Construction of experimental samples for bearing fault diagnosis based on DC-GANomaly

[0165] The fault diagnosis experiment samples were constructed as follows: The three types of fault datasets were randomly separated, with 80% and 20% of the samples used as part of the training and test sets, respectively. The epoch was set to 100, and the batch size to 64. The improved DC-GANomaly model was trained using the training set. After training, bearing fault samples were generated, resulting in bearing fault samples generated by DC-GANomaly. These generated bearing fault samples were added to the training set to expand the imbalanced bearing fault sample set. The model was validated using the test set.

[0166] 3.2 Model Training

[0167] (1) Bearing anomaly detection process based on DC-GANomaly

[0168] The bearing anomaly detection process based on DC-GANomaly is as follows: Figure 3 As shown, the DC-GANomaly generator has a large loss in the initial stage of iteration, but it converges quickly thereafter, reaching Nash equilibrium with the discriminator loss. The detection accuracy reaches 92.6% when the number of iterations approaches 45.

[0169] In summary, compared with the original GANomaly, the DC-GANomaly deep convolutional network model of this invention achieves anomaly detection and fault classification of bearing vibration signals, and performs better in both detection accuracy and diagnostic accuracy.

[0170] In addition, combined Figure 11 , Figure 12 As can be seen, the two figures below show the fault diagnosis accuracy with the addition of fault data categories and the results compared to the accuracy of other models, respectively. Figure 11Experimental results show that as the number of fault data categories and training iterations increases, the model's fault diagnosis accuracy improves, approaching 100%, demonstrating the model's effectiveness in bearing fault diagnosis. Figure 12 It is evident that the model proposed in this paper has significant advantages over traditional machine learning models.

[0171] With the rapid development of science and technology and the continuous improvement of industrial levels, more and more mechanical equipment is being put into use. Almost all mechanical equipment uses bearing components, and bearings play a crucial role. Most bearings operate in harsh environments with complex and variable operating conditions, leading to an increased frequency of bearing failures. Therefore, accurate detection and classification of bearing failures can improve the economic efficiency of mechanical equipment. However, bearing failure data is scarce, and there is a serious data imbalance problem, which poses significant challenges to deep learning network models based on large amounts of training data.

[0172] This invention, in conjunction with embodiments and accompanying drawings, takes a model fusion and data augmentation perspective. Leveraging the powerful data generation capabilities currently demonstrated by Generative Adversarial Networks (GANs), it utilizes the deep convolutional network model DC-GANomaly to achieve anomaly detection and data-augmented fault diagnosis in bearings, further improving detection and diagnosis accuracy. In engineering practice, this improves the efficiency of anomaly detection and fault diagnosis, saves human and material resources, enhances the accuracy of anomaly detection and fault diagnosis, and improves the economic benefits of mechanical equipment.

Claims

1. A bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks, characterized in that, include: (1) Construct a model based on deep convolutional generative adversarial networks A deep convolutional network model, DC-GANomaly, composed of CNN and generative adversarial network is constructed. The DC-GANomaly deep convolutional network model includes: a generator, generated samples, an encoder, and a discriminator. The generator is a bowtie convolutional autoencoder neural network architecture. The DC-GANomaly deep convolutional network model is based on the original GANomaly network framework, using a bowtie convolutional autoencoder and a DCGAN convolutional neural network architecture as the main network structure, and adding an auxiliary classifier consisting of four fully connected layers for fault category classification in the discriminator. (2) Training of the deep convolutional network model DC-GANomaly In the anomaly detection training phase, the normal one-dimensional vibration signal of the input bearing and the manually labeled normal signal are used to train the model until the entire network model reaches Nash equilibrium, and the deep convolutional network model DC-GANomaly trained in the anomaly detection phase is obtained. In the fault diagnosis training phase, the one-dimensional vibration signal of the input bearing fault and manually labeled fault categories are used to train the model until the entire model reaches Nash equilibrium. The deep convolutional network model DC-GANomaly is used to generate fault data and add it to the initial training set. The expanded training set is used to train the classifier until the loss function converges, and then the training stops, resulting in the classifier trained in the fault diagnosis phase. (3) Bearing abnormality detection and fault diagnosis The one-dimensional vibration signal of the bearing acquired in real time is input into the DC-GANomaly deep convolutional network model trained in the anomaly detection stage to obtain the detection result of whether an anomaly has occurred. The abnormal detection results are then input into the classifier trained in the fault diagnosis stage, which outputs the corresponding fault category label.

2. The bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks according to claim 1, characterized in that, The deep convolutional network model DC-GANomaly, An auxiliary classifier consisting of four fully connected layers is added after the discriminator for bearing fault diagnosis. The deep convolutional network model DC-GANomaly can not only detect anomalies in bearing data but also classify bearing fault categories. At the same time, it can enhance the training set with GAN-generated data, supplement the imbalanced sample set, and improve the accuracy of bearing fault diagnosis. The generator of the deep convolutional network model DC-GANomaly has two inputs: a real sample and the corresponding fault category label of the real sample. The generated sample is then compared with the features of normal one-dimensional vibration signal data by the encoder. After comparing with the set threshold, it is detected whether an anomaly has occurred. The discriminator generates the bearing fault classification diagnosis result as the output. The threshold is set according to the scenario, and an anomaly is determined when the value is greater than the threshold.

3. The bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks according to claim 1, characterized in that, The DC-GANomaly deep convolutional network model trained during the anomaly detection phase specifically includes: The original one-dimensional vibration signal of all normal data The samples were converted into time-frequency graphs using wavelet transform. The time-frequency graph with embedded human-labeled normal tags is input into the generator, mapped to a low-dimensional reconstruction graph, and the generator produces new samples. Generate corresponding manually labeled normal and abnormal tags. : New sample Marked as 0, and time-frequency plot samples It is marked as category label 1; Then the sample combinations are loaded, and their authenticity is identified and classified; Subsequently, time-frequency graph samples Labels are recorded as New sample Labels are recorded as The prediction of the time-frequency graph samples is denoted as... The prediction for the new sample is denoted as ; The discriminator is trained by minimizing the loss function of the training model; the cross-entropy loss function of the discriminator is calculated using the following formula: （I） (II) (III) In formulas (I), (II), and (III), The loss function between the predicted label and the true label of the time-frequency map sample obtained after inputting the time-frequency map sample into the discriminator; Refers to the binary classification cross-entropy loss function; The loss function between the predicted label of the generated sample and the generated label of the generated sample obtained after inputting the new sample into the discriminator; The cross-entropy loss function of the discriminator; New sample The label is set to 1 and sent to the discriminator, which passes through new samples with non-zero labels; by minimizing To adjust and complete the training of the generator; the features extracted from the original one-dimensional vibration signal by the discriminator are denoted as... The features extracted from the new sample by the discriminator are denoted as follows: The bottleneck feature generated by the generator from the original one-dimensional vibration signal is denoted as... The encoded features extracted from the new sample by the generator are denoted as... The formula for calculating the cross-entropy loss function of the generator is as follows: (IV) （V） (WE) (VII) In formulas (IV), (V), (VI) and (VII), , The feature matching loss is represented by calculating the L2 distance between the features extracted by the discriminator from the original one-dimensional vibration signal and the feature representations of the features extracted by the discriminator from the new sample, which reduces the instability of GAN training and updates the generator based on the internal structure of the discriminator. , To represent context loss, calculate the L1 distance between the original one-dimensional vibration signal and the new sample; , This represents the encoder loss, which minimizes the distance between the bottleneck features of the input and the encoded features extracted by the generator from the new sample. The discriminator is used for: when the frequency map sample When fed into the deep convolutional network model DC-GANomaly, it makes the output value predict the time-frequency map samples. Close to 1; when inputting a newly generated sample At that time, the discriminator attempts to make predictions based on time-frequency map samples. If the value is close to 0, the new sample data is judged as false; simultaneously, the prediction of the time-frequency graph samples is affected. Approximate the value to 1 so that the generator can successfully pass the discriminator.

4. The bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks according to claim 1, characterized in that, The specific methods for diagnosing bearing faults in step (3) include: All bearing fault original one-dimensional vibration signals After wavelet transform, the data is converted into a 1*32*32 time-frequency graph. Time-frequency graph samples with manually labeled fault categories are input into the generator and mapped to a low-dimensional reconstructed graph. The new samples are then used to generate the final graph. Generate corresponding category labels ; New sample Marked as 0, and time-frequency plot samples The samples are labeled as category label 1, and then the sample combinations are loaded to identify and classify authenticity. The discriminator is trained by minimizing the loss function of the training model. The formula for calculating the cross-entropy loss function of the discriminator is as follows: （X） In formula (X), Refers to the binary classification cross-entropy loss function; This refers to the cross-entropy loss function of the discriminator; The label is set to 1 and sent to the discriminator. The discriminator cannot pass the newly generated sample with a true label of 0 by minimizing... To adjust and complete the generator training, the cross-entropy loss function of the generator in the deep convolutional network model DC-GANomaly is calculated as follows: (XI) In formula (XI), , The feature matching loss is represented by the L2 distance between the original one-dimensional vibration signal and the feature representation of the new sample after processing by the discriminator; the features extracted from the original one-dimensional vibration signal by the discriminator are denoted as... The features extracted from the new sample by the discriminator are denoted as follows: ; The discriminator is used for: when the frequency map sample When fed into the deep convolutional network model DC-GANomaly, it makes the output value predict the time-frequency map samples. Close to 1; when inputting a newly generated sample At that time, the discriminator attempts to make predictions based on time-frequency map samples. If the value is close to 0, the new sample data is judged as false; simultaneously, the prediction of the time-frequency graph samples is affected. Approximate the value to 1 so that the generator can successfully pass the discriminator.

5. The bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks according to claim 1, characterized in that, In step (2), the augmentation method corresponding to the augmented training set includes: After the deep convolutional network model DC-GANomaly is trained, the generator generates bearing vibration signal data of different fault types according to the given labels. The expanded dataset is denoted as... The expanded data labels are denoted as The classification labels generated by the classifier are denoted as .

6. The bearing anomaly detection and fault diagnosis method based on deep convolutional generative adversarial networks according to claim 5, characterized in that, In step (2), the method of training the classifier using the expanded training set includes: The formula for calculating the cross-entropy loss function of the classifier is as follows: (XII) In formula (XII), , This refers to the multi-class cross-entropy loss function.

Images