Small sample based bearing fault diagnosis method and system based on deep adaptive network

Abstract

The application relates to a bearing fault diagnosis method and system based on a deep adaptive network under small samples. The diagnosis method comprises the following steps: collecting vibration signals in the bearing operation process and storing the vibration signals in a server; pre-processing the vibration signals, carrying out one-dimensional vibration signal two-dimensional image gray valueization, and storing the vibration signals in a database; extracting image data in the database, carrying out data enhancement based on a deep convolutional generative adversarial network, and constructing a database for fault diagnosis; and using a deep adaptive network to carry out small sample fault diagnosis. The diagnosis system comprises a preprocessing module, a data enhancement module and a diagnosis module. The deep convolutional generative adversarial network and the deep adaptive network are combined for use, training of the network can be completed under unfamiliar working conditions by using a small amount of labels, the training time and the training cost of the network are reduced, the portability of the model is enhanced, and the model has good robustness for small sample working conditions.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of fault diagnosis, and particularly relates to a bearing fault diagnosis method and system based on a deep adaptive network under a small sample. BACKGROUND

[0002] As key components of high-speed trains, wind turbines, helicopters, numerical control machine tools and other major equipment, the running state of rolling bearings directly affects the reliability and stability of the entire equipment. Any form of bearing failure can lead to potential hidden dangers and unexpected safety problems in the equipment, so advanced fault diagnosis technology is needed to evaluate the state and monitor the quality of rolling bearings to minimize economic losses.

[0003] In recent years, many researchers have successfully developed many intelligent bearing fault diagnosis methods. In particular, bearing fault diagnosis methods based on deep learning can quickly and effectively analyze mechanical monitoring signals and accurately diagnose bearing faults without requiring much prior professional knowledge. However, training a high-performance intelligent fault diagnosis model often requires the following two conditions to be met: 1) labeled fault data; 2) training and testing data that meet the same probability distribution. In fact, many studies have shown that the success of machine intelligence fault diagnosis depends on these two conditions.

[0004] However, in actual industrial applications, it is difficult to obtain labeled fault data. Secondly, machines often go through a long degradation process from a healthy state to a failure. This means that obtaining fault data from machines is both time-consuming and expensive. In addition, in actual industrial applications, the operating conditions of machines are constantly changing, and there is usually a distribution difference between training and testing data. When the training data and testing data belong to different operating conditions, the accuracy of the trained model in the test set will decrease significantly.

[0005] Through the above analysis, the problems and defects of the prior art are:

[0006] 1. Most existing fault diagnosis methods start with one-dimensional features of vibration signals, and the data contains limited features.

[0007] 2. Existing fault diagnosis methods require manual feature extraction of fault signals or use time-frequency domain analysis to process signals.

[0008] 3. For small sample fault diagnosis, existing fault diagnosis methods lack intuitive display of data enhancement.

[0009] 4. Existing fault diagnosis methods require a large amount of labeled data for model training, and perform poorly in unknown operating conditions without labels.

[0010] 5. The existing fault diagnosis method has poor migration and robustness of the model. In actual industrial application, the operation condition of the machine is complex and changeable. The network needs to be retrained under different working conditions, which greatly increases the training time and cost. SUMMARY

[0011] To solve some or all of the problems in the prior art, the first aspect of the present application provides a bearing fault diagnosis method based on a deep adaptive network under a small sample, which comprises the following steps:

[0012] Collecting vibration signals of the bearing under different equipment and different working conditions by an acceleration sensor and storing them in a server;

[0013] Preprocessing the vibration signals in the server to convert one-dimensional vibration signals into two-dimensional image gray values and store them in the database in the form of image data;

[0014] Extracting image data in the database and performing data enhancement based on a deep convolutional generative adversarial network to construct a database for fault diagnosis;

[0015] Using a deep adaptive network to perform small sample fault diagnosis, wherein the enhanced data of the small sample and the data sample under another working condition are respectively input as source domain data and target domain data, feature extraction is performed through the convolutional layer of the convolutional neural network, and the data under the two working conditions is aligned in the fully connected layer of the convolutional neural network to reduce the difference between the source domain data and the target domain data.

[0016] Further, the preprocessing converts one-dimensional vibration signals into two-dimensional image gray values according to the following formula:

[0017] P(j,k)=round{[L((j-1)*M+k)-Min(L)] / [Max(L)-Min(L)]*255}

[0018] Wherein, j, k represent the rows and columns of the converted image matrix, M is the size of the matrix, P(j, k) is the pixel point of the matrix, L((j-1)*M+k) represents the specific vibration signal, Min(L) and Max(L) represent the maximum and minimum values of the signal, respectively.

[0019] Further, the deep convolutional generative adversarial network comprises a generator and a discriminator.

[0020] Further, the generator is composed of four deconvolutional layers, and the activation function is ReLU, which is defined as

[0021]

[0022] Where m is the input to the activation function and q is the output of the activation function.

[0023] Furthermore, the discriminator consists of four convolutional layers, with the activation function being LeakyReLU, which is defined as:

[0024]

[0025] Where v is the input of the activation function, u is the output of the activation function, and a is a positive number greater than 1;

[0026] The discriminator's loss function is chosen to be the binary cross-entropy loss BCELoss, which is defined as:

[0027] BCELoss=-[y*log(p)+(1-y)*log(1-p)]

[0028] Where p is the discriminant probability predicted by the deep convolutional generative adversarial network, and y is the true label (with a value of 0 or 1).

[0029] Furthermore, the operation of the deep convolutional generative adversarial network is as follows:

[0030] In the generator's structure, a 100-dimensional noise tensor and a label tensor are input. The noise tensor and the label tensor are concatenated through a deconvolution layer to obtain an n*n dimensional neuron. 2 For the number of vibration signals contained in each image, the ReLU function is used to distribute the weights of the neurons in the interval (-1, 1), thus matching the real image data;

[0031] The discriminator unfolds the n*n image data into n*n-dimensional neurons, passes them through 4 convolutional layers to obtain a 1-dimensional label tensor, and uses the LeakyReLU function to map the weights of the label tensor onto (0,1) as the probability of this discrimination.

[0032] Furthermore, the training of the deep convolutional generative adversarial network is completed through the mutual iteration of the generator and the discriminator. In the first stage, the discriminator is fixed and the generator is trained. The generator continuously generates fake data, and the discriminator judges it. Through feedback and training, the discriminator's judgment result is correct. In the second stage, the generator is fixed and the discriminator is trained. The discriminator gradually improves its discrimination ability through continuous training and can eventually accurately judge all generated fake images. After multiple iterations of training, the generator and adversarial network achieve optimal performance. The generator generates multiple samples for each fault state, so that the number of samples for each fault state meets the requirements.

[0033] Furthermore, the backbone network of the deep adaptation network is the AlexNet convolutional neural network, which consists of 5 convolutional layers and 3 fully connected layers.

[0034] Furthermore, the domain confusion loss during backpropagation training of the deep adaptation network is measured using the maximum mean difference between the source and target domains, where the maximum mean difference is defined as:

[0035]

[0036] Among them, D s With D t Let n represent the source and target domain datasets, respectively. s With n t Φ(·) represents the number of samples in the source and target domain datasets, and Φ(·) is the feature mapping function that maps the feature vectors of the source and target domains to the reproducing kernel Hilbert space. In order to calculate the difference in mean between two domains, and These represent the outputs of the source and target domains in the fully connected layer, respectively.

[0037] A second aspect of the present invention provides a bearing fault diagnosis system based on a deep adaptive network for small sample sizes, the system comprising:

[0038] The preprocessing module is used to convert the one-dimensional vibration signal of the bearing into a two-dimensional image grayscale value.

[0039] The data augmentation module is used for data augmentation of preprocessed image data. Data augmentation is performed based on a deep convolutional generative adversarial network to build a database for fault diagnosis; and

[0040] The diagnostic module is used by the deep adaptive network to perform small-sample fault diagnosis. It takes source domain data and target domain data as input, and uses convolutional neural network for feature extraction and data alignment to reduce the difference between source domain data and target domain data.

[0041] Compared with the prior art, the present invention has the following advantages:

[0042] 1. Visualizing one-dimensional vibration signals provides an intuitive way to observe them, avoiding time-frequency domain analysis. Visualized data is also beneficial for the use of deep learning technology.

[0043] 2. For small sample data, this invention provides a data augmentation method based on deep convolutional generative adversarial network (DCGAN) adversarial learning, which avoids manual feature extraction and outputs the generated data in the form of images, providing an intuitive basis for observing data augmentation techniques.

[0044] 3. This invention provides an end-to-end deep learning technology for small-sample fault diagnosis under unknown working conditions, which can ignore the intermediate processing of vibration signals and has strong network portability.

[0045] 4. The deep learning network proposed in this invention adopts pre-training technology, which avoids retraining the network when porting it to different working conditions, thus greatly reducing the training time and training cost of the network. Attached Figure Description

[0046] To further illustrate the above and other advantages and features of the various embodiments of the present invention, a more specific description of the various embodiments of the present invention will be presented with reference to the accompanying drawings. It is to be understood that these drawings depict only typical embodiments of the invention and are therefore not intended to limit its scope. In the drawings, identical or corresponding parts will be indicated by identical or similar reference numerals for clarity.

[0047] Figure 1 This is a schematic diagram of the fault diagnosis method of the present invention;

[0048] Figure 2 This is a schematic diagram of the network structure of the deep convolutional generative adversarial network of the present invention;

[0049] Figure 3 This is a schematic diagram of the network structure of the deep adaptive network of the present invention;

[0050] Figure 4 This is a table illustrating the impact of the difference between the maximum mean values ​​of non-adopted and adopted methods on diagnostic accuracy in this invention;

[0051] Figure 5 This is a schematic diagram of the fault diagnosis system of the present invention. Detailed Implementation

[0052] In the following description, the invention is described with reference to various embodiments. However, those skilled in the art will recognize that the embodiments may be practiced without one or more specific details or in conjunction with other alternatives and / or additional methods or components. In other instances, well-known structures or operations are not shown or described in detail so as not to obscure the inventive points of the invention. Similarly, for illustrative purposes, specific numbers and configurations are set forth to provide a comprehensive understanding of embodiments of the invention. However, the invention is not limited to these specific details.

[0053] In this specification, references to "an embodiment" or "this embodiment" mean that a particular feature, structure, or characteristic described in connection with that embodiment is included in at least one embodiment of the invention. The phrase "in one embodiment" appearing throughout this specification does not necessarily refer to the same embodiment in all instances.

[0054] It should be noted that the embodiments of the present invention describe the method steps in a specific order; however, this is only for illustrating the specific embodiment and not for limiting the order of the steps. On the contrary, in different embodiments of the present invention, the order of the steps can be adjusted according to actual needs.

[0055] In this invention, the term "small sample" refers to a sample size that is less than 20% of the existing sample size.

[0056] In this invention, the modules of the system according to the invention can be implemented using software, hardware, firmware, or a combination thereof. When a module is implemented using software, its function can be implemented through computer program flow. For example, the module can be implemented using code segments (such as code segments in languages ​​like C and C++) stored in a storage device (such as a hard disk, memory, etc.), wherein the corresponding function of the module can be implemented when the code segment is executed by a processor. When a module is implemented using hardware, its function can be implemented by setting a corresponding hardware structure. For example, the module's function can be implemented by hardware programming a programmable device such as a field-programmable gate array (FPGA), or by designing an application-specific integrated circuit (ASIC) that includes multiple transistors, resistors, capacitors, and other electronic devices. When a module is implemented using firmware, the module's function can be written into a read-only memory such as an EPROM or EEPROM in the form of program code, and the corresponding function of the module can be implemented when the program code is executed by a processor. In addition, some functions of the module may need to be implemented by separate hardware or by working in cooperation with the hardware. For example, the detection function is implemented by the corresponding sensor (such as a proximity sensor, accelerometer, gyroscope, etc.), the signal transmission function is implemented by the corresponding communication device (such as a Bluetooth device, infrared communication device, baseband communication device, Wi-Fi communication device, etc.), the output function is implemented by the corresponding output device (such as a display, speaker, etc.), and so on.

[0057] The technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Figure 1 This is a schematic diagram of the fault diagnosis method of the present invention. As shown in the figure, the diagnosis method includes the following steps:

[0058] First, vibration signals from the bearing during operation are collected and stored on a server. This step involves collecting vibration signals from the bearing under different operating conditions in different equipment using an accelerometer. The fault diagnosis method of this invention is mainly used for bearing fault diagnosis. It classifies the one-dimensional data points of the bearing fault vibration signals collected by the accelerometer, where each data point represents the amplitude of the bearing during operation.

[0059] Next, the vibration signals are preprocessed by converting the one-dimensional vibration signals into two-dimensional image grayscale values, which are then stored in the database. After grayscale conversion, the two-dimensional images are stored in the database as image data. This step requires determining the image size and number of images based on the actual size of the vibration signal dataset. Specifically, the number of signals required for two-dimensional image conversion must be less than the number of signals in the collected vibration signal dataset to avoid duplicate coverage of the same signal by different images. Taking the rolling bearing fault diagnosis dataset from Jiangnan University as an example, one type of fault dataset contains over 500,000 vibration signal points. If each image is defined as 56*56 pixels, meaning each image contains 3136 vibration signals, and 100 images are selected, a total of 313,600 signal points are needed. In this case, the number of signal points required for two-dimensional image conversion is less than the number of signals in the collected vibration signal dataset, thus avoiding duplicate coverage of the same signal by different images. The size of the two-dimensional image in this step can also be adjusted according to the vibration signal dataset. For example, using the vibration signal dataset from Western Reserve University, which contains more than 100,000 signal points, if each image pixel is still 56*56, and 100 images are selected, a total of 313,600 signal points are needed. At this time, the number of signal points required for two-dimensional image generation is much greater than the number of signals in the collected vibration signal dataset. The pixel of each image can be adjusted to 16*16, then 100 images will require a total of 25,600 signal points. At this time, the number of signal points required for two-dimensional image generation is less than the number of signals in the collected vibration signal dataset.

[0060] The preprocessing involves converting the one-dimensional vibration signal into a two-dimensional image grayscale value according to the following formula:

[0061] P(j,k)=round{[L((j-1)*M+k)-Min(L)] / [Max(L)-Min(L)]*255}

[0062] Where j and k represent the rows and columns of the transformed image matrix, M is the size of the matrix, P(j,k) is the number of pixels in the matrix, L((j-1)*M+k) represents the specific vibration signal, and Min(L) and Max(L) represent the maximum and minimum values ​​of the signal segment, respectively. Taking the rolling bearing fault diagnosis dataset from Jiangnan University as an example, each image has 56*56 pixels, meaning each image contains 3136 vibration signals. This formula can convert the 3136 vibration signals into 3136 grayscale values ​​between 0 and 255, and the newly obtained grayscale values ​​are used as pixels.

[0063] Taking the collected rolling bearing fault diagnosis dataset from Jiangnan University as an example, the preprocessing process is explained. Four fault state signals with a rotation speed of 800 rpm are selected from the dataset. The four selected fault state signals are converted into two-dimensional grayscale values ​​to generate 300 56×56 two-dimensional grayscale image samples, resulting in a total of 1200 image samples.

[0064] Next, image data is extracted from the database and augmented using a deep convolutional generative adversarial network (DCGAN) to construct a database for fault diagnosis. DCGAN combines deep convolutional neural networks (CNNs) with generative adversarial networks (GANs) for unsupervised learning.

[0065] Figure 2 This is a schematic diagram of the deep convolutional generative adversarial network (DGAN) of this invention. As shown in the figure, the DGAN includes a generator and a discriminator. DCGAN improves upon the generator and discriminator based on the generative adversarial network. Specifically, the generator consists of four deconvolutional layers with ReLU activation function; the discriminator consists of four convolutional layers with LeakyReLU activation function. An activation function is a function that operates on neurons in an artificial neural network, responsible for mapping the neuron's input to its output.

[0066] The activation function ReLU (Rectified Linear Unit) is defined as follows:

[0067]

[0068] Where m is the input to the activation function and q is the output of the activation function.

[0069] The activation function LeakyReLU is defined as follows:

[0070]

[0071] Where v is the input of the activation function, u is the output of the activation function, and a is a positive number greater than 1;

[0072] The discriminator's loss function is chosen to be the binary cross-entropy loss BCELoss, used to calculate the binary cross-entropy loss between the true label and the predicted label on each data sample. BCELoss is defined as:

[0073] BCELoss=-[y*log(p)+(1-y)*log(1-p)]

[0074] Where p is the discriminant probability predicted by the deep convolutional generative adversarial network, and y is the true label (with a value of 0 or 1).

[0075] The operation of the deep convolutional generative adversarial network is as follows:

[0076] In the generator's structure, a 100-dimensional noise tensor and a label tensor are input. The noise tensor and the label tensor are concatenated through a deconvolution layer to obtain an n*n dimensional neuron. 2 For the number of vibration signals contained in each image, the ReLU function is used to distribute the weights of the neurons in the interval (-1, 1), thus matching the real image data;

[0077] The discriminator unfolds the n*n image data into n*n-dimensional neurons, passes them through 4 convolutional layers to obtain a 1-dimensional label tensor, and uses the LeakyReLU function to map the weights of the label tensor onto (0,1) as the probability of this discrimination.

[0078] The training of the deep convolutional generative adversarial network is completed through the mutual iteration of the generator and the discriminator. In the first stage, the discriminator is fixed and the generator is trained. The generator continuously generates fake data, and the discriminator judges it. Through feedback and training, the discriminator's judgment result is correct. In the second stage, the generator is fixed and the discriminator is trained. The discriminator gradually improves its discrimination ability through continuous training and can eventually accurately judge all generated fake images. After multiple iterations of training, the generator and adversarial network achieve the best performance. The generator generates multiple samples for each fault state, so that the number of samples for each fault state meets the requirements.

[0079] Taking the collected rolling bearing fault diagnosis dataset from Jiangnan University as an example, this paper illustrates the data augmentation process based on deep convolutional generative adversarial network. Based on the visualization of vibration signals, 300 image samples of each fault state are augmented using DCGAN. The generator trained for 300 iterations generates 900 samples for each fault state. Combined with the original 300 samples for each fault state, the number of samples for each fault state reaches 1200, and the total number of samples for the four fault states reaches 4800.

[0080] Finally, a deep adaptation network is used for small-sample fault diagnosis. The deep adaptation network (DAN) uses a deep network as a carrier for adaptation and transfer. This step, based on data augmentation, uses augmented small-sample data and data samples from another operating condition as source and target domain data inputs, respectively. Feature extraction is performed through the convolutional layers of a convolutional neural network, and the data from the two operating conditions are aligned in the fully connected layers of the convolutional neural network to reduce the difference between the source and target domain data.

[0081] Figure 3 This is a schematic diagram of the Deep Adaptive Network (DAN) of the present invention. As shown in the figure, samples at a rotation speed of 600 rpm are selected as source domain data, and samples at a rotation speed of 800 rpm are selected as target domain data. The backbone network of the Deep Adaptive Network (DAN) is an AlexNet convolutional neural network, which consists of 5 convolutional layers and 3 fully connected layers. The Deep Adaptive Network (DAN) outputs source domain data and target domain data through the same convolutional and fully connected layers of the same backbone network, that is, the source domain network and the target domain network are the same, constructing a twin network. The fully connected layers of the network align the data from the source domain and the data from the target domain to reduce the differences between the source domain data and the target domain data. The Deep Adaptive Network (DAN) has two losses during backpropagation training: one is the classification loss L from the labeled data in the source domain. y One is the domain confusion loss L at the output of the fully connected layer. d The goal of backpropagation is to minimize both losses simultaneously, thereby enabling the training of the deep adaptive network. The classification loss L for labeled data in the source domain is... y It is obtained from the cross-entropy loss of the source domain network, i.e., the BCELoss mentioned in the data augmentation process. The domain confusion loss L output at the fully connected layer... d The maximum mean discrepancy (MMD) between the source and target domains is used as a metric. Maximum Mean Discrepancy (MMD) is a widely used loss function in domain adaptation, primarily used to measure the distance between the distributions of two distinct but related random variables. The maximum mean discrepancy (MMD) is defined as follows:

[0082]

[0083] Among them, D s With D t Let n represent the source and target domain datasets, respectively. s With n t Φ(·) represents the number of samples in the source and target domain datasets, and Φ(·) is the feature mapping function that maps the feature vectors of the source and target domains to the reproducing kernel Hilbert space. In order to calculate the difference in mean between two domains, and Let L represent the outputs of the source and target domains in the fully connected layer, respectively. The domain confusion loss L can be obtained from this equation. d Finally, by minimizing these two losses, the network parameters are optimized during backpropagation to complete the network training.

[0084] The following example illustrates the impact of the bearing fault diagnosis method based on deep adaptive networks under small sample conditions provided by this invention on the accuracy of fault diagnosis. Jiangnan University's bearing fault diagnosis project collected fault data at three speeds: 600 rpm, 800 rpm, and 1000 rpm. These three speeds are considered as three operating conditions, A, B, and C, resulting in six transfer tasks. The transfer task A→B is defined as using A as the source domain and B as the target domain. For the 600 rpm speed, signal imaging technology is used to generate 1200 image samples for each of the four fault states, totaling 4800 image samples. For the 800 rpm samples, 300 image samples are collected for each fault state to simulate small sample data, resulting in a total of 1200 images for the four fault states. All data at 800 rpm are then augmented using a deep convolutional generative adversarial network (DCGAN), increasing the original 300 samples for each fault state to 1200 samples. All labeled samples at 600 rpm and augmented unlabeled samples at 800 rpm were used as inputs to train a deep adaptive network. Training was completed after the neural network converged. The trained network can handle unlabeled data with small sample sizes very well. Figure 4 This is a table illustrating the impact of using and not using the Maximum Mean Difference (MMD) on diagnostic accuracy in this invention. Figure 4 As shown, using the same data processing method (one-dimensional signal to two-dimensional form) and small sample enhancement technique (DCGAN), the accuracy of adding the maximum mean difference (MMD) technique is higher than that of not adding the maximum mean difference (MMD) technique. The accuracy of adding the maximum mean difference (MMD) technique is above 90%.

[0085] This invention proposes a data augmentation method using Deep Convolutional Generative Adversarial Networks (DCGANs) to address the data imbalance problem in fault diagnosis. DCGANs augment small sample data and output them as images, improving the accuracy of the generated data and providing an intuitive observation method. This invention is the first to combine Deep Convolutional Generative Adversarial Networks (DCGANs) with Deep Adaptive Networks (DANs). DANs address the problem of insufficient labels in fault diagnosis under different operating conditions. By combining DCGANs with DANs, network training can be completed with a small number of labels under unfamiliar operating conditions, significantly reducing training time and cost, enhancing model portability, and demonstrating good robustness to small sample conditions.

[0086] The present invention also provides a bearing fault diagnosis system based on deep adaptive networks for small sample sizes. Figure 5 This is a schematic diagram of the fault diagnosis system of the present invention, as shown below. Figure 5 As shown, the system includes:

[0087] The preprocessing module is used to convert the one-dimensional vibration signal of the bearing into a two-dimensional image grayscale value.

[0088] The data augmentation module is used for data augmentation of preprocessed image data. Data augmentation is performed based on a deep convolutional generative adversarial network to build a database for fault diagnosis; and

[0089] The diagnostic module is used by the deep adaptive network to perform small-sample fault diagnosis. It takes source domain data and target domain data as input, and uses convolutional neural network for feature extraction and data alignment to reduce the difference between source domain data and target domain data.

[0090] Although various embodiments of the invention have been described above, it should be understood that they are presented by way of example only and not as limitations. It will be apparent to those skilled in the art that various combinations, modifications, and alterations can be made without departing from the spirit and scope of the invention. Therefore, the breadth and scope of the invention disclosed herein should not be limited by the exemplary embodiments disclosed above, but should be defined solely by the appended claims and their equivalents.

Claims

1. A bearing fault diagnosis method based on deep adaptive networks under small sample conditions, characterized in that, Includes the following steps: Vibration signals of the bearing under different operating conditions in different equipment are collected by an accelerometer and stored in a server; The vibration signal is preprocessed on the server so that the one-dimensional vibration signal can be converted into two-dimensional image grayscale and stored in the database as image data. Image data is extracted from the database and augmented using a deep convolutional generative adversarial network to construct a database for fault diagnosis. A deep adaptive network is used for small-sample fault diagnosis. The enhanced small-sample data and data samples from another operating condition are used as the source domain data and target domain data input, respectively. Feature extraction is performed through the convolutional layer of the convolutional neural network, and the data from the two operating conditions are aligned in the fully connected layer of the convolutional neural network to reduce the difference between the source domain data and the target domain data.

2. The method according to claim 1, characterized in that, The preprocessing involves converting the one-dimensional vibration signal into a two-dimensional image grayscale value according to the following formula: Where j,k represent the rows and columns of the transformed image matrix, M is the size of the matrix, P(j,k) is the number of pixels in the matrix, and L((j-1)) is the number of pixels in the matrix. M+k) represents the specific vibration signal, and Min(L) and Max(L) represent the maximum and minimum values ​​of the signal segment, respectively.

3. The method according to claim 1, characterized in that, The deep convolutional generative adversarial network includes a generator and a discriminator.

4. The method according to claim 3, characterized in that, The generator consists of four deconvolutional layers, with ReLU as the activation function. ReLU is defined as follows: Where m is the input to the activation function and q is the output of the activation function.

5. The method according to claim 3, characterized in that, The discriminator consists of four convolutional layers, with the activation function being LeakyReLU. LeakyReLU is defined as follows: Where v is the input of the activation function, u is the output of the activation function, and a is a positive number greater than 1; The loss function of the discriminator is chosen as the binary cross-entropy loss BCELoss, which is defined as: Where p is the discriminant probability predicted by the deep convolutional generative adversarial network, and y is the true label (with a value of 0 or 1).

6. The method according to any one of claims 3-5, characterized in that, The operation of the deep convolutional generative adversarial network is as follows: In the generator's structure, a 100-dimensional noise tensor and a label tensor are input. The noise tensor and the label tensor are concatenated through a deconvolution layer to obtain an n-dimensional generator. n-dimensional neurons, n 2 For the number of vibration signals contained in each image, the ReLU function is used to distribute the weights of the neurons in the interval (-1, 1) to match the real image data; The discriminator will n The image data of n is expanded into n An n-dimensional neuron is processed through four convolutional layers to obtain a 1-dimensional label tensor. The LeakyReLU function is used to map the weights of the label tensor onto (0,1), which serve as the probability of this discrimination.

7. The method according to claim 1, characterized in that, The training of the deep convolutional generative adversarial network is completed through the mutual iteration of the generator and the discriminator. In the first stage, the discriminator is fixed and the generator is trained. The generator continuously generates fake data and the discriminator makes a judgment. Through feedback and training, the discriminator judges the result as true. In the second stage, the generator is fixed and the discriminator is trained. The discriminator gradually improves its discrimination ability through continuous training and eventually can accurately identify all generated fake images. After multiple iterations of training, the generator and adversary achieve optimal performance. The generator generates multiple samples for each fault state, ensuring that the number of samples for each fault state meets the requirements.

8. The method according to claim 1, characterized in that, The backbone of the deep adaptive network is the AlexNet convolutional neural network, which consists of 5 convolutional layers and 3 fully connected layers.

9. The method according to claim 1, characterized in that, The domain confusion loss of the deep adaptation network during backpropagation training is measured using the maximum mean difference between the source and target domains. The maximum mean difference is defined as follows: in, and These represent the source and target domain datasets, respectively. and This represents the number of samples in the source and target domain datasets. The feature mapping function maps the feature vectors of the source and target domains to the reproducing kernel Hilbert space. In order to calculate the difference in mean between two domains, and These represent the outputs of the source and target domains in the fully connected layer, respectively.

10. A bearing fault diagnosis system based on deep adaptive networks for small sample sizes, characterized in that, Includes the following modules: The preprocessing module is used to convert the one-dimensional vibration signal of the bearing into a two-dimensional image grayscale value. The data augmentation module is used for data augmentation of preprocessed image data. The data augmentation is based on deep convolutional generative adversarial networks and builds a database for fault diagnosis. as well as The diagnostic module is used by the deep adaptive network to perform small-sample fault diagnosis. The input is source domain data and target domain data. The small-sample enhanced data and data samples from another working condition are used as source domain data and target domain data, respectively. Through feature extraction and data alignment by convolutional neural network, the difference between source domain data and target domain data is reduced.

Images