Fire-fighting fan bearing fault diagnosis method, electronic equipment and storage medium

Abstract

The invention provides a fault diagnosis method for a bearing of a fire-fighting fan, electronic equipment and a storage medium. The method comprises the following steps: acquiring vibration data of the bearing in three directions of an X axis, a Y axis and a Z axis within a preset time period; for each direction, converting the vibration data in a preset time period in the direction into a two-dimensional feature map; splicing the two-dimensional feature maps corresponding to each direction to obtain a three-channel input tensor; inputting the three-channel input tensor into a TextCNN auto-encoder module of a trained fault diagnosis model to obtain potential space compression features of the three-channel input tensor; and inputting the potential space compression features into a convolutional network module of the fault diagnosis model to obtain a fault category prediction result output by the convolutional network module. The method is used for more comprehensively capturing the running state of the bearing and improving the fault diagnosis efficiency and accuracy.

Description

Technical Field

[0001] This application relates to the field of mechanical equipment fault diagnosis technology, and more specifically, to a fault diagnosis method, electronic equipment, and storage medium for a fire-fighting fan bearing. Background Technology

[0002] Bearings, as critical support components in rotating machinery, play a vital role in the safe operation and service life of the entire machine. Especially in safety-critical equipment such as fire-fighting fans, the health of the bearings directly affects the effective and continuous smoke extraction during a fire, thereby ensuring personnel safety and fire control. However, existing bearing fault diagnosis technologies typically rely solely on vibration signals in a single direction. These signals are then processed through frequency domain transformation or manual feature extraction before being fed into a classification model for fault diagnosis. This method has limited information utilization dimensions and a lengthy processing chain, failing to meet the urgent needs for efficiency and accuracy in bearing fault diagnosis, particularly for fire-fighting fan bearings. Summary of the Invention

[0003] The purpose of this application is to provide a fault diagnosis method, electronic device, and storage medium for fire fan bearings, so as to more comprehensively capture the operating status of the bearings and improve the efficiency and accuracy of fault diagnosis.

[0004] To achieve the above objectives, the technical solutions adopted in the embodiments of this application are as follows:

[0005] In a first aspect, an embodiment of this application provides a fault diagnosis method for a fire-fighting fan bearing, comprising: acquiring vibration data of the bearing in three directions (X-axis, Y-axis, and Z-axis) within a preset time period; converting the vibration data within the preset time period in each direction into a two-dimensional feature map; concatenating the two-dimensional feature maps corresponding to each direction to obtain a three-channel input tensor; inputting the three-channel input tensor into the TextCNN autoencoder module of a trained fault diagnosis model to obtain the latent spatial compression features of the three-channel input tensor; and inputting the latent spatial compression features into the convolutional network module of the fault diagnosis model to obtain the fault category prediction result output by the convolutional network module.

[0006] In one embodiment, converting vibration data within a preset time period in the direction into a two-dimensional feature map includes: slidingly dividing the vibration data into multiple time-domain subsequences of equal length to generate multiple time-domain subsequences; and arranging the multiple time-domain subsequences in a matrix to obtain the two-dimensional feature map.

[0007] In one embodiment, the step of stitching together the two-dimensional feature maps corresponding to each direction to obtain a three-channel input tensor includes: taking the two-dimensional feature map corresponding to each direction as data for one channel, and arranging the two-dimensional feature maps of the X-axis, Y-axis, and Z-axis in sequence to obtain the three-channel input tensor.

[0008] In one embodiment, the preset time period is one of the time windows within a fixed time period. The method further includes: acquiring vibration data from different time windows multiple times in the form of a sliding window to obtain multiple window data; inputting the window data into the fault diagnosis model for each window data to obtain a fault category prediction result, the fault category prediction result including a probability value corresponding to each fault category; for each fault category, summing the probability values ​​corresponding to the fault category in different window data to obtain a comprehensive probability corresponding to each fault category; normalizing the comprehensive probability corresponding to each fault category, and selecting the fault category corresponding to the maximum probability as the final fault category identification result.

[0009] In one embodiment, before inputting the three-channel input tensor into the trained TextCNN autoencoder module of the fault diagnosis model to obtain the latent spatial compression features of the three-channel input tensor, the method further includes: acquiring three-dimensional sample data with different fault categories; converting the three-dimensional sample data into two-dimensional feature maps on the X-axis, Y-axis, and Z-axis; using the two-dimensional feature maps on the X-axis, Y-axis, and Z-axis as inputs to the TextCNN autoencoder to train the TextCNN autoencoder module of the fault diagnosis model separately; fixing the parameters of the TextCNN autoencoder module, using the output of the TextCNN autoencoder module as input to a convolutional network to train the convolutional network module of the fault diagnosis model separately.

[0010] In one embodiment, the step of using the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map as input to a TextCNN autoencoder to train the TextCNN autoencoder module of the fault diagnosis model separately includes: processing the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map through a TextCNN autoencoder and a fully connected layer respectively to obtain X-axis extraction results, Y-axis extraction results, and Z-axis extraction results; adjusting the parameters of the TextCNN autoencoder to minimize the difference between the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map and the X-axis extraction results, Y-axis extraction results, and Z-axis extraction results, thereby obtaining the trained TextCNN autoencoder module of the fault diagnosis model.

[0011] In one embodiment, the step of fixing the parameters of the TextCNN autoencoder module and using the output of the TextCNN autoencoder module as the input of the convolutional network to train the convolutional network module of the fault diagnosis model separately includes: fixing the parameters of the TextCNN autoencoder module and using the output of the TextCNN autoencoder module as the input of the convolutional network, adjusting the parameters of the convolutional network to minimize the error between the fault category prediction result output by the convolutional network and the actual fault category probability, thereby obtaining the trained convolutional network module.

[0012] In one embodiment, the step of processing the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map through a TextCNN autoencoder and a fully connected layer to obtain the X-axis extraction result, Y-axis extraction result, and Z-axis extraction result includes:

[0013] The X-axis two-dimensional feature map, Y-axis two-dimensional feature map and Z-axis two-dimensional feature map are respectively input into the TextCNN autoencoder;

[0014] Multiple sliding kernels of fixed size are set up. The sliding kernels slide along the horizontal and vertical directions on the X-axis two-dimensional feature map, the Y-axis two-dimensional feature map and the Z-axis two-dimensional feature map respectively, and perform matrix multiplication with the corresponding two-dimensional feature map to obtain local features of fixed size.

[0015] Max pooling is performed on each local feature of a fixed size to obtain the max-pooled features;

[0016] The max-pooled features are concatenated and mapped through a fully connected layer to obtain the X-axis, Y-axis, and Z-axis extraction results.

[0017] In one embodiment, before training the convolutional network module of the fault diagnosis model separately by keeping the parameters of the TextCNN autoencoder module unchanged and using the output of the TextCNN autoencoder module as the input of the convolutional network, the method further includes:

[0018] Randomly initialize the weights and biases of the trainable convolutional kernel.

[0019] According to a second aspect of this application, an electronic device is provided, comprising: a processor; and a memory for storing processor-executable instructions; wherein the processor is configured to perform the fault diagnosis method for the fire fan bearing described in the above embodiments.

[0020] According to a third aspect of this application, a storage medium is provided that stores a computer program, which can be executed by a processor to perform the fault diagnosis method for the fire fan bearing described in the above embodiments.

[0021] According to the fourth aspect of this application, a computer program product is provided, including a computer program / instructions that, when executed by a processor, implement the fault diagnosis method for the fire fan bearing described in the above embodiments.

[0022] The beneficial effects of this application are as follows: by directly collecting vibration data of the fire fan bearing in the three vertical directions of X, Y, and Z, and converting it into a two-dimensional feature map, the ability to comprehensively capture the bearing's operating status is effectively enhanced, and richer information is obtained.

[0023] By concatenating these two-dimensional feature maps into an output tensor and inputting it into the TextCNN autoencoder, the model can automatically extract latent spatial compression features, thereby more effectively identifying and learning fault features and significantly improving the accuracy of fault diagnosis.

[0024] The above steps omit the frequency domain transformation and manual feature extraction steps, and directly process the original signal, simplifying the diagnostic process, reducing coupling errors in intermediate links, thereby improving diagnostic efficiency and meeting the requirements of high efficiency and accuracy for fault diagnosis of fire fan bearings. Attached Figure Description

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

[0026] Figure 1 This is a schematic diagram of the architecture of the execution system provided in the embodiments of this application;

[0027] Figure 2 A flowchart illustrating the fire fan bearing fault diagnosis method provided in this application embodiment;

[0028] Figure 3 A schematic diagram illustrating the process of converting vibration data into a two-dimensional feature map as provided in the embodiments of this application;

[0029] Figure 4 This is a schematic diagram illustrating the two-dimensional feature map construction and stitching process provided in an embodiment of this application;

[0030] Figure 5 This is a schematic diagram illustrating the distributed integrated prediction process provided in an embodiment of this application.

[0031] Figure 6 A schematic diagram of the distributed integrated prediction process provided in an embodiment of this application;

[0032] Figure 7 A schematic diagram of the prediction result table provided in the embodiments of this application;

[0033] Figure 8 A schematic diagram of the training system for the fault diagnosis model provided in the embodiments of this application;

[0034] Figure 9 A schematic diagram of the training process of the fault diagnosis model provided in the embodiments of this application;

[0035] Figure 10 A schematic diagram illustrating the training of the fault diagnosis model provided in an embodiment of this application;

[0036] Figure 11 This is a schematic diagram of the first training process of the TextCNN autoencoder module provided in an embodiment of this application;

[0037] Figure 12 This is a schematic diagram of the second training process of the TextCNN autoencoder module provided in an embodiment of this application;

[0038] Figure 13 A schematic diagram of the training process for feature extraction and data compression of the autoencoder provided in the embodiments of this application;

[0039] Figure 14 This is a schematic diagram of the training process for the autoencoder feature extraction process provided in the embodiments of this application. Detailed Implementation

[0040] The technical solutions in the embodiments of this application will now be described with reference to the accompanying drawings.

[0041] Figure 1 This is a schematic diagram of the architecture of the execution system provided in the embodiments of this application; the fault diagnosis method for the fire-fighting fan bearing of this application can be executed by the execution system. Figure 1 As shown, the execution system can consist of a three-dimensional vibration data acquisition module, a data preprocessing module, and a fault diagnosis model module. The three-dimensional vibration data acquisition module is responsible for collecting data, the data preprocessing module processes the acquired data, and the fault diagnosis model module is used for bearing fault identification.

[0042] Figure 2 This is a flowchart illustrating the fire fan bearing fault diagnosis method provided in an embodiment of this application; as shown below. Figure 2 As shown, the method includes the following steps S100-S500:

[0043] Step S100: Obtain vibration data of the bearing in the X-axis, Y-axis and Z-axis directions within a preset time period.

[0044] Among them, using sensors or other measuring devices to collect vibration data at the same location of the fire-fighting fan bearing within a preset time period, and simultaneously collecting vibration data in three directions, can more comprehensively capture the dynamic behavior of the bearing, providing a rich source of original information for fault diagnosis.

[0045] The specific process is as follows: Step 1: Collect three-dimensional vibration data of the bearing within a preset time period at a frequency of 500 times per second. The data is divided into three axes: x-axis (horizontal direction), y-axis (vertical direction), and z-axis (perpendicular to the ground). 10019 samples need to be collected for each axis. The collected x-axis, y-axis, and z-axis data are represented by X = {x1, x2, ..., x...} 10019}、Y={y1,y2,...,y 10019} and Z = {z1, z2, ..., z 10019} represents the vibration data collected along the x-axis, the vibration data collected along the y-axis, and the vibration data collected along the z-axis.

[0046] Step S200: For each direction, convert the vibration data within a preset time period in that direction into a two-dimensional feature map.

[0047] The preset time period refers to a fixed time period pre-set during the data acquisition phase, used for data acquisition and feature map generation. During this time period, the system continuously acquires vibration data of the bearing in the X, Y, and Z axes. This time period should be long enough to ensure that the periodic characteristics in the bearing vibration signal can be captured; for example, at least one minute (30,000 data points) of data needs to be acquired.

[0048] Vibration data in each of the X, Y, and Z axes represent the dynamic behavior of the bearing within a preset time period. This data was originally in a one-dimensional time series format. Converting the original one-dimensional time vibration series data into a two-dimensional feature map makes the data structured, which can better capture and represent the periodicity and patterns in the vibration signal, providing a basis for feature extraction and facilitating subsequent processing and analysis.

[0049] In one embodiment, Figure 3 This is a schematic diagram illustrating the process of converting vibration data into a two-dimensional feature map, as provided in an embodiment of this application. Figure 4 This is a schematic diagram of the two-dimensional feature map construction and stitching process provided in the embodiments of this application, combined with Figure 3 and Figure 4 As shown, step S200, which converts vibration data within a preset time period in a direction into a two-dimensional feature map, includes the following steps S210-S220:

[0050] Step S210: Slide the vibration data into a fixed length to generate multiple time-domain subsequences of equal length.

[0051] Step S220: Arrange multiple time-domain subsequences in a matrix in sequence to obtain a two-dimensional feature map.

[0052] The specific processes of steps S210 and S220 are as follows: Execute steps 2-6:

[0053] Step 2: Set the list variable INPUT and make it an empty list to serve as the input data list.

[0054] Step 3: Roll the X, Y, and Z values ​​from Step 1 into multiple time-domain subsequences of equal length by grouping them into groups of 10,000. The resulting data will be in the following format:

[0055] XG = {xg1, xg2, ..., xg} 20}

[0056] YG = {yg1, yg2, ..., yg} 20}

[0057] ZG = {zg1, zg2, ..., zg} 20}

[0058] in

[0059] xg1={x1,x2,...,x 10000}, xg j ={x j ,x j+1 ,...,x j+9999}, xg 20 ={x 20 ,x 21 ,...,x 10019}

[0060] yg1={y1,y2,...,y 10000}, yg j ={y j ,y j+1 ,...,y j+9999},

[0061] yg 20 ={y 20 ,y 21 ,...,y 10019}

[0062] zg1={z1,z2,...,z 10000}, zg j ={z j,z j+1 ,...,z j+9999}, zg 20 ={z 20 ,z 21 ,...,z 10019}

[0063] Step 4: Set variable b and set b = 1.

[0064] Execute step 5: According to xg b Generate an xgt matrix of size 100*100. b ,in:

[0065] xgt b [a][v] = xg b [100*(a-1)+v]

[0066] That is, xgt b The value in the a-th row and v-th column is taken from xg b The 100*(a-1)+v value of the sequence, where a ranges from 1 to 100 and v ranges from 1 to 100. This can be represented by the following matrix:

[0067]

[0068] Right now

[0069]

[0070] The resulting xgt b It can be viewed as a two-dimensional feature map of the x-axis vibration over a certain time period, where xgt b The first row in the table can be considered the first time-domain subsequence, the second row can be considered the second time-domain subsequence, and so on.

[0071] Similarly, it can be based on yg b and zg b Generate ygt matrices of size 100*100 respectively b and zgt b These can be viewed as two-dimensional feature maps of the y-axis and z-axis vibrations over a specific time period. This completes the process of arranging multiple time-domain subsequences in a matrix to obtain the two-dimensional feature maps.

[0072] Step 6: If b < 20, increment variable b by 1 and repeat step 5 above. Otherwise, proceed to step 7. This step checks whether all predetermined data sets have been processed, providing a complete dataset for subsequent feature extraction and model output. At this point, data preprocessing is complete.

[0073] Since the bearing rotation is a periodic motion, the original vibration sequence obtained is also periodic data, meaning xg1 is periodic data. The two-dimensional feature xgt1 obtained by segmenting the data according to a certain length and then concatenating them into a matrix contains periodic features above, below, left, and right of each feature point. Therefore, subsequent convolution operations using a two-dimensional convolutional neural network make it easier to extract the periodic features from the original time series, thereby improving prediction accuracy.

[0074] Step S300: Concatenate the two-dimensional feature maps corresponding to each direction to obtain a three-channel input tensor.

[0075] The three-channel input tensor refers to a three-dimensional tensor formed by concatenating three two-dimensional feature maps along the channel dimension. The three channels of this tensor correspond to vibration data along the X, Y, and Z axes, respectively, and can be directly used as input by deep learning models, especially convolutional neural networks (CNNs). By concatenating these channels, vibration information from three directions is integrated into a single tensor, enabling the model to consider vibration features from multiple directions simultaneously, thereby improving the accuracy of fault diagnosis.

[0076] In one embodiment, step S300, which involves stitching together the two-dimensional feature maps corresponding to each direction to obtain a three-channel input tensor, includes: treating the two-dimensional feature map corresponding to each direction as data for one channel, and arranging the two-dimensional feature maps of the X-axis, Y-axis, and Z-axis in sequence to obtain a three-channel input tensor.

[0077] Specifically, such as Figure 4As shown, taking the xg1 sequence along the X-axis, Y-axis, and Z-axis, the yg1 sequence along the Y-axis, and the zg1 sequence along the Z-axis as examples, assuming each xg1, yg1, and zg1 sequence has a length of 12, and is segmented with a segmentation length of 4, each can be segmented into 4 data segments: ①, ②, ③, and ④ (i.e., 4 time-domain subsequences). These are then concatenated in sequence to form 4×4 matrices xgt1, ygt1, and zgt1. This completes the transformation from one-dimensional features to two-dimensional features. Next, the two-dimensional feature maps in these three directions are arranged and concatenated into a uniform three-channel input tensor, with the X-axis feature map as the first channel, the Y-axis feature map as the second channel, and the Z-axis feature map as the third channel. This arrangement ensures that each channel represents vibration information in a specific direction. The arranged two-dimensional feature maps are combined into a three-channel input tensor and fed into a two-dimensional convolution kernel for convolution operation to extract features. This three-channel input tensor contains vibration information of the bearing in three perpendicular directions, providing the model with a comprehensive data perspective. This input structure allows the model to consider features from multiple directions simultaneously, thereby improving the accuracy and reliability of fault diagnosis.

[0078] Step S400: Input the three-channel input tensor into the TextCNN autoencoder module of the trained fault diagnosis model to obtain the latent spatial compression features of the three-channel input tensor.

[0079] The fault diagnosis model includes a TextCNN autoencoder module and a convolutional network module. The trained fault diagnosis model can be trained using the methods described in the examples below, which will not be repeated here.

[0080] The TextCNN (Text Convolutional Neural Network) autoencoder module is a model structure that combines the characteristics of convolutional neural networks (CNNs) and autoencoders. An autoencoder is a special type of neural network that reconstructs input data by learning a compressed representation of the input data; it is typically used for unsupervised learning and feature extraction. The TextCNN autoencoder leverages the local feature extraction capabilities of CNNs to encode and decode text data, thereby learning an effective representation of the text data. While the TextCNN autoencoder is particularly suitable for processing text data, it is applied to vibration data in this application.

[0081] The three-channel input tensor xgt b ygt b and zgt bThe input is fed into the TextCNN autoencoder module, which automatically learns and extracts latent spatial compression features from the three-channel input tensor. These latent spatial compression features are compressed representations of the original data, retaining key information but with lower dimensionality than the original data. This helps reduce the computational complexity of the model while improving its generalization ability. Extracting latent spatial compression features through the TextCNN autoencoder module helps improve the accuracy and reliability of fault diagnosis models.

[0082] For example, the three-channel input tensor xgt b ygt b and zgt b The input is fed into the TextCNN autoencoder module to obtain the latent spatial compressed representation (i.e., latent spatial compressed features), which yields xgth. b ygth b and zgth b Their sizes are all (80, 80). Then xgth b ygth b and zgth b Merging along the first dimension forms a tensor of size (3, 80, 80) in. b , tensor in b Add it to the end of the list INPUT for use in convolutional neural networks.

[0083] Step S500: Input the latent spatial compression features into the convolutional network module of the fault diagnosis model to obtain the fault category prediction results output by the convolutional network module.

[0084] The convolutional network module is a deep learning model consisting of multiple convolutional layers, pooling layers, and fully connected layers. It receives latent spatial compressed features extracted by the TextCNN autoencoder and further extracts and learns these features through multiple convolutional and pooling operations. The fully connected layers map the extracted features to the output space, i.e., fault categories, to achieve accurate classification of fire fan bearing fault types. The fault category prediction result output by the convolutional network module is the probability value corresponding to each fault category. The specific process is as follows: Steps 7-17 are executed.

[0085] Step 7: Load the parameters of the trained conv1, conv2, and conv3 convolutions, along with other parameters, from the training system; that is, load W. conv1 B conv1 W conv2 B conv2 W conv3 B conv3 W linear Blinear Parameters such as these.

[0086] Step 8: The length of the list INPUT is 20, so it can be viewed as a tensor with a shape and size of (20, 3, 80, 80). Perform a convolution operation on the tensor INPUT using kernel conv1 to obtain the output tensor output_conv1, i.e.:

[0087] output_conv1 = conv1(INPUT)

[0088] At this point, the shape and size of the tensor output_conv1 are (20, 15, 80, 80).

[0089] Step 9: Perform max pooling on the result of step 8 using a 2x2 MaxPooling operation with a sliding window step size of (2,2), to obtain the output tensor `output_maxpool1`.

[0090] output_maxpool1=MaxPooling(output_conv1)

[0091] At this point, the shape and size of the tensor output_maxpool1 are (20, 15, 40, 40).

[0092] Step 10: Perform a convolution operation on output_maxpool1 using convolution kernel conv2 to obtain the output tensor output_conv2, i.e.

[0093] output_conv2=conv2(output_maxpool1)

[0094] At this point, the shape and size of the tensor output_conv2 are (20, 15, 38, 38).

[0095] Step 11: Perform max pooling on output_conv2 using a MaxPooling operation with a size of 2*2 and a sliding window step size of (2,2) to obtain the output tensor output_maxpool2, i.e., output_maxpool2 = MaxPooling(output_conv2).

[0096] At this point, the shape and size of the tensor output_maxpool2 are (20, 15, 19, 19).

[0097] Step 12: Perform a convolution operation on output_maxpool2 using the convolution kernel conv3 to obtain the output tensor output_conv3, i.e.

[0098] output_conv3=conv3(output_maxpool2)

[0099] At this point, the shape and size of the tensor output_conv3 are (20,3,19,19).

[0100] Step 13: Perform max pooling on output_conv3 using a MaxPooling operation with a size of 2*2 and a sliding window step size of (2,2) to obtain the output tensor output_maxpool3, i.e., output_maxpool3 = MaxPooling(output_conv3).

[0101] At this point, the shape and size of the tensor output_maxpool3 are (20,3,9,9).

[0102] Step 14: Change the shape and size of the tensor output_maxpool3 to (20, 243).

[0103] Step 15: Perform the operation according to the following formula and method:

[0104] output = output_maxpool3 × W linear +B linear

[0105] The shape and size of the tensor output are (20, class_num).

[0106] Step 16: Use the softmax function to operate on the tensor output in the second dimension, that is, to transform the output vector of each sample into a probability distribution. This yields:

[0107] softmax_output=softmax(output)

[0108] The shape and size of the tensor softmax_output are (20, class_num).

[0109] Execution step 17: At this point, softmax_output[i][j] represents the probability that the fault type is j in the i-th prediction.

[0110] The convolutional network module simplifies the diagnostic process through automated feature learning and classification, improving the accuracy and efficiency of diagnosis, while enhancing the model's ability to generalize to new data, thus providing an efficient and reliable solution for bearing fault diagnosis.

[0111] In one embodiment, after obtaining the fault category prediction result once, a distributed integrated prediction method can also be used. The method described in steps S100-S500 above is used to make multiple predictions on the neighboring data, and then a normalized voting method is used to select the most likely fault type currently existing in the bearing. Specifically, steps 18-20 are executed as follows:

[0112] Step 18: Calculate using the following formula to obtain the shape size (class... n The tensor ensemble_output of um).

[0113]

[0114] Here, 'a' ranges from 1 to 'class_num'.

[0115] Step 19: Using the softmax function to operate on the tensor ensemble_output, we can obtain...

[0116] predict_result=softmax(ensemble_output)

[0117] Wherein, predict_result has a shape size of (class_num), and predict_result[i] refers to the probability that the system predicts the current bearing state as fault type i.

[0118] Step 20: Find the index of the largest value in predict_result, for example, 'a'. This means that the system has determined the current bearing operating condition to be the category corresponding to fault type 'a'.

[0119] This concludes the distributed integration prediction.

[0120] In one embodiment, Figure 5 This is a schematic diagram illustrating the distributed integrated prediction process provided in an embodiment of this application. Figure 6 This is a schematic diagram of the distributed integrated prediction process provided in the embodiments of this application, combined with Figure 5 and Figure 6 As shown, the preset time period is one of the time windows within a fixed time period. The distributed ensemble prediction includes the following steps S510-S540:

[0121] Step S510: Obtain vibration data from different time windows multiple times in the form of a sliding window to obtain multiple window data.

[0122] Specifically, the distributed ensemble prediction process is as described in steps 18-20 above. Assuming a total of 20 predictions are made in this step, taking 20 predictions as an example, within a preset fixed time period, a specific time window is selected, and vibration data from different time windows are acquired multiple times using a fixed-length sliding window. This process is repeated 20 times to obtain multiple window data sets. The window data obtained each time is fed into the model for prediction. By sliding the time window within a fixed time period, the vibration characteristics of the bearing at different time points can be continuously captured, providing the model with continuous time-series data.

[0123] Step S520: For each window of data, input the window data into the fault diagnosis model to obtain the fault category prediction result, which includes the probability value corresponding to each fault category.

[0124] The data from each sliding window is input into a trained fault diagnosis model. The model independently predicts the data for each window and outputs the probability value corresponding to each fault category. For example, Figure 7 A schematic diagram of the prediction result table provided in the embodiments of this application, as shown below. Figure 7 As shown, the prediction results are categorized into five types: healthy, 0.5mm inner ring fault, 1mm inner ring fault, 0.5mm outer ring fault, and 1mm outer ring fault. Each prediction yields the probability of each of these five categories. A total of 20 predictions are made.

[0125] Step S530: For each fault category, sum the probability values ​​corresponding to the fault category in different window data to obtain the comprehensive probability corresponding to each fault category.

[0126] Even if the probabilities of the same fault category under different time windows are accumulated to obtain the comprehensive prediction result for each fault category, a more stable probability estimate can be obtained.

[0127] Step S540: Normalize the comprehensive probability corresponding to each fault category, and select the fault category corresponding to the maximum probability as the final fault category identification result.

[0128] This method involves normalizing the data and summing the probability values ​​of each fault category across different time windows to obtain a comprehensive predicted probability for each category. The category with the highest comprehensive predicted probability is then selected as the final fault diagnosis result, thereby improving the accuracy and reliability of fault diagnosis. Since data exhibits occasional fluctuations, single predictions are prone to errors. This method reduces random errors in single predictions by integrating data from multiple time windows, making fault diagnosis more stable and reliable. For example, based on the comprehensive predicted probability, in... Figure 7 In the process, the model will determine that the bearing currently has a 0.5mm inner ring fault.

[0129] Figure 8 This is a schematic diagram of the training system for the fault diagnosis model provided in the embodiments of this application, as shown below. Figure 8 As shown, the three-dimensional vibration data acquisition module collects three-dimensional vibration data of the bearing, and then inputs the data into the data preprocessing module for data preprocessing. Next, the data preprocessing module inputs the processed data into the algorithm model module for training. The algorithm model module includes a TextCNN autoencoder module and a convolutional network module. Finally, the training system saves the trained model, thus obtaining the trained fault diagnosis model.

[0130] Figure 9 This is a schematic diagram of the training process of the fault diagnosis model provided in the embodiments of this application, combined with Figure 8 and Figure 9 As shown, before inputting the three-channel input tensor into the TextCNN autoencoder module of the trained fault diagnosis model to obtain the latent space compression features of the three-channel input tensor, the fault diagnosis model needs to be trained. The training process of the fault diagnosis model includes the following steps S600-S900:

[0131] Step S600: Obtain three-dimensional sample data with different fault categories.

[0132] The specific training steps are as follows: Step 1: Divide the sample bearing faults into two categories: inner ring wear and outer ring wear. Within each category, subcategories can be set based on the degree of bearing wear, such as inner ring faults with a wear degree of 0.7mm, 0.9mm, and 1.1mm, and outer ring faults with wear degrees of 0.7mm, 0.9mm, and 1.1mm, etc. These can be set according to actual needs. Set the motor speed to T (revolutions per second), and assume there are a total of class_num fault types (including the no-fault category). Artificially induce each fault in the sample bearings and test them to obtain training data for model training.

[0133] The three-dimensional vibration data acquisition module collects three-dimensional vibration data of the sample bearing under each fault category at a fixed acquisition frequency, dividing the data into three directions: x-axis, y-axis, and z-axis. Data acquisition is performed at a frequency of 500 times per second. The acquired x-axis, y-axis, and z-axis data are respectively... and It means that X i This represents the vibration data along the x-axis collected under fault category i, and the Y-axis... i Z represents the vibration data along the y-axis collected under fault category i. i This represents the vibration data along the z-axis collected under fault category i. This represents the vibration value collected in the j-th order under fault category i. n must be greater than 30000, meaning at least one minute of data must be collected. Therefore, there are a total of X. 1 Y 1 Z 1 X 2 Y 2 Z 2 ... X class_num Y class_num Z class _num With so much data, we were able to acquire three-dimensional sample data for different fault categories.

[0134] Step S700: Convert the three-dimensional sample data into two-dimensional feature maps on the X-axis, Y-axis, and Z-axis.

[0135] This involves data preprocessing and training set generation, specifically as follows: Steps 2 through 8 are executed:

[0136] Step 2: Set the list variable INPUT to an empty list to serve as the input data list for the training set. Set the list variable LABEL to an empty list to serve as the sample label list for the training set. Set the error convergence value of the loss function to DELTA.

[0137] Perform step 3: For each X in step 1 i Y i Z i The data is grouped in a rolling manner with each group having a length of 10,000, and a corresponding label sequence is generated simultaneously. The data format after grouping is as follows:

[0138]

[0139]

[0140]

[0141] L i ={i,i,...,i}

[0142] in

[0143]

[0144]

[0145]

[0146]

[0147]

[0148]

[0149] L i This refers to a label sequence with length m and L. i The vibration data for the j-th label on the x, y, and z axes are respectively and

[0150] Step 4: Set the variable u and let u = 1.

[0151] Step 5: Set variable b and set b = 1.

[0152] Execute step 6: According to Generate a matrix of size 100*100 in

[0153]

[0154] Right now The value in the a-th row and v-th column is taken from The 100*(a-1)+v value of the sequence, where a ranges from 1 to 100 and v ranges from 1 to 100. This can be represented by the following matrix:

[0155]

[0156] Right now

[0157]

[0158] This generates It can be viewed as a two-dimensional feature map of the x-axis vibration acquired over a certain time period under the fault category u.

[0159] Similarly, it can be based on and Generate matrices of size 100*100 respectively. and They can be viewed as two-dimensional feature maps of the y-axis and z-axis vibrations acquired over a certain time period under the fault category u.

[0160] Execute step 7: If b < m, increment variable b by 1, and then repeat step 6. Otherwise, execute step 8.

[0161] Execute step 8: If u < class_num, increment variable u by 1, and then repeat steps 5 to 7. Otherwise, execute step 9 below.

[0162] This completes the data preprocessing and training set generation.

[0163] Step S800: Use the two-dimensional feature map of the X-axis, the two-dimensional feature map of the Y-axis, and the two-dimensional feature map of the Z-axis as inputs to the TextCNN autoencoder and train them separately to obtain the TextCNN autoencoder module of the fault diagnosis model.

[0164] Figure 10 A schematic diagram illustrating the training of the fault diagnosis model provided in an embodiment of this application; Figure 11 This is a schematic diagram of the first training process of the TextCNN autoencoder module provided in the embodiments of this application, combined with Figure 10 and Figure 11 As shown, specifically, the data input into the TextCNN autoencoder module is and (Corresponding to the two-dimensional feature maps along the X-axis, Y-axis, and Z-axis respectively), for and Each module has an independent TextCNN autoencoder. During training, the TextCNN autoencoder module extracts features from the input data, and the training process is also independent. Using TextCNN as the autoencoder model allows for training of the latent space compressed representation without any labeled corpus. This reduces a significant amount of manual annotation work and improves accuracy. This unsupervised training process makes fault feature extraction and classification more intelligent, and is more helpful in identifying the fault types of mechanical components such as bearings.

[0165] In one embodiment, Figure 12 This is a schematic diagram of the second training process of the TextCNN autoencoder module provided in the embodiments of this application, combined with Figure 11 and Figure 12 As shown, step S800 involves using the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map as inputs to the TextCNN autoencoder to train the TextCNN autoencoder module of the fault diagnosis model separately, including the following steps S810-S820:

[0166] Step S810: The X-axis two-dimensional feature map, Y-axis two-dimensional feature map and Z-axis two-dimensional feature map are processed by the TextCNN autoencoder and fully connected layer respectively to obtain the X-axis extraction result, Y-axis extraction result and Z-axis extraction result.

[0167] Specifically, using the two-dimensional feature map along the X-axis To illustrate, the two-dimensional feature map along the X-axis is input into a TextCNN autoencoder for feature extraction. Convolutional layers capture local features, and pooling layers obtain global features. These features are then mapped to specific fault categories using fully connected layers. The resulting X-axis, Y-axis, and Z-axis extraction results, xgthb, ygthb, and zgthb, are compressed representations of the input feature map in the latent space, each with a size of 80×80. These results will be used for subsequent fault diagnosis model training to improve the model's performance and accuracy.

[0168] Specifically, as shown in step 9: using the two-dimensional feature map along the X-axis. To illustrate, firstly... After passing through the TextCNN autoencoder, you will get It represents the input data. A compressed representation of the latent space. Then, a fully connected approach will be used to... Restore to The size. The goal of learning is the input data. In other words, during the training phase of the TextCNN autoencoder module, and The loss value is calculated, and then gradient descent is used to update the parameters of the TextCNN autoencoder. After the TextCNN autoencoder is trained, its parameter values ​​remain unchanged during the training of subsequent convolutional networks; they are fixed and will be used for the training of subsequent convolutional networks.

[0169] In one embodiment, Figure 13 A schematic diagram of the training process for feature extraction and data compression of the autoencoder provided in the embodiments of this application; Figure 14 This is a schematic diagram of the training process for the autoencoder feature extraction process provided in the embodiments of this application, combined with Figure 13 and Figure 14 As shown, step S810 involves processing the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map through a TextCNN autoencoder and a fully connected layer to obtain the X-axis extraction result, Y-axis extraction result, and Z-axis extraction result, including the following steps S811-S814:

[0170] Step S811: Input the X-axis two-dimensional feature map, Y-axis two-dimensional feature map and Z-axis two-dimensional feature map into the TextCNN autoencoder respectively.

[0171] Step S812: Set multiple sliding kernels of fixed size. The sliding kernels slide along the horizontal and vertical directions on the X-axis two-dimensional feature map, Y-axis two-dimensional feature map and Z-axis two-dimensional feature map respectively, and perform matrix multiplication with the corresponding two-dimensional feature map to obtain local features of fixed size.

[0172] Step S813: Perform max pooling on each local feature of a fixed size to obtain the max pooled features.

[0173] Step S814: Concatenate the max-pooled features and map them to a fully connected layer to obtain the X-axis extraction result, Y-axis extraction result, and Z-axis extraction result.

[0174] For details regarding steps S811-S814, please refer to training steps 9.1-9.5:

[0175] Training Step 9.1: Set the sliding kernel. The sliding kernel (also called a convolution kernel or filter) is a fixed-size matrix that slides across the input data (such as X-axis, Y-axis, and Z-axis two-dimensional feature maps) to extract local features of the data. Using the X-axis two-dimensional feature map... To illustrate, we first set up six fixed-size sliding kernels, with sizes of (20, 100), (40, 100), (60, 100), (100, 20), (100, 40), and (100, 60). These six kernel sizes allow for feature extraction operations at three scales: local, intermediate, and global. These kernels can capture features of the input data at different scales, thereby extracting richer feature information.

[0176] Training step 9.2, Sliding and Matrix Multiplication: The sliding kernel of TextCNN slides horizontally and vertically across the X-axis, Y-axis, and Z-axis two-dimensional feature maps, respectively, and multiplies with... Matrix multiplication is performed once for each sliding step, thereby extracting features. Through matrix multiplication, the sliding kernel interacts with the input data to extract local features. This operation can capture subtle changes and patterns in the input data, providing a foundation for subsequent feature extraction.

[0177] Training step 9.3, Result Generation: After the sliding operation is complete, six fixed-size results (result 1 to result 6) are obtained. The size of these six results is also fixed. These results contain feature representations of the input data at different scales and locations, providing a foundation for subsequent max pooling operations and helping to extract key features.

[0178] Training step 9.4, Max pooling operation: Max pooling is used to process the six results and extract the most significant features. Max pooling helps reduce computational complexity, prevents overfitting, and improves the model's generalization ability.

[0179] Training step 9.5, concatenating results: The results after max pooling are concatenated to obtain result 7. The size of result 7 is (6,1), which integrates features of different scales to form a unified feature representation. The concatenated result contains multi-scale feature information, providing richer input for the fully connected layer.

[0180] Training step 9.6, repetition and mapping: Repeat the copy of result 7 to obtain result 8, and then map result 8 to a specified size (e.g., using a fully connected layer). (size). Through fully connected layers, features are integrated and mapped to the output layer, providing input for the final prediction of the TextCNN autoencoder model.

[0181] Training step 9.7, Output mapping: The features are then mapped to the output layer through a fully connected layer to obtain the X-axis extraction result, Y-axis extraction result, and Z-axis extraction result (i.e.,...). Mapped to The autoencoder process is completed by processing the features through a fully connected layer. The resulting autoencoder output is then used in subsequent convolutional networks or other processing steps, such as fault diagnosis.

[0182] Through these steps, the TextCNN autoencoder can effectively extract key features from the input data and compress them into a smaller representation, providing meaningful input for subsequent fault diagnosis models. Using TextCNN as an autoencoder is more computationally efficient and requires fewer parameters. This can accelerate training and inference while reducing the use of computing resources.

[0183] Step S820: Adjust the parameters of the TextCNN autoencoder to minimize the differences between the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map and the X-axis extraction result, Y-axis extraction result, and Z-axis extraction result, to obtain the TextCNN autoencoder module of the trained fault diagnosis model.

[0184] In the training phase of the TextCNN autoencoder module, the original input is calculated. and The loss value between the original input and the autoencoder output measures the difference between the original input and the autoencoder output. Specifically, it calculates the differences between the X-axis, Y-axis, and Z-axis 2D feature maps and the X-axis, Y-axis, and Z-axis extraction results, respectively. Gradient descent is then used to update the parameters of the TextCNN autoencoder, and the loss value is minimized (even if the difference is minimal) by adjusting the autoencoder parameters. After the TextCNN autoencoder training is complete, its parameter values ​​are fixed and no longer change.

[0185] Step S900: Keep the parameters of the TextCNN autoencoder module unchanged, use the output of the TextCNN autoencoder module as the input of the convolutional network, and train the convolutional network module of the fault diagnosis model separately.

[0186] Specifically, assuming that after the TextCNN autoencoder is trained, for all and The latent spatial compressed representation extracted from the input data is represented as follows and Furthermore, by setting the parameters of the TextCNN autoencoder, the size of the latent space compressed representation is (80, 80), i.e. and The size of each is (80, 80).

[0187] Will and Merging along the first dimension results in a tensor with a shape and size of (3, 80, 80). tensor Add it to the end of the INPUT list. Also, add L... u The b-th element is added to the end of the list LABEL, thereby combining the features extracted by the autoencoder with the corresponding labels to form a training method for the subsequent convolutional network.

[0188] In one embodiment, before training the convolutional network module, the method further includes: randomly initializing the weights and biases of the trainable convolutional kernel.

[0189] The specific process is as follows: Step 10: Set the convolution kernel conv1, with its input channels set to 3, output channels set to 15, kernel size set to 3*3, sliding window stride set to (1,1), and padding mode set to (1,1). All weights in the convolution kernel conv1 are represented by W. conv1 This indicates that all biases are represented by B. conv1 express.

[0190] Set the convolution kernel conv2, with 15 input channels, 15 output channels, a kernel size of 5x5, a sliding window stride of (1,1), and a padding mode of (1,1). All weights in the convolution kernel conv2 are represented by W. conv2 This indicates that all biases are represented by B. conv2 express.

[0191] Set the convolution kernel to conv3, with 15 input channels, 3 output channels, a kernel size of 3x3, a sliding window stride of (1,1), and a padding mode of (1,1). All weights in the conv3 kernel are represented by W. conv3 This indicates that all biases are represented by B. conv3 express.

[0192] Set the trainable weights W to a size of 243 × class_num. linear and a bias B of size class_num linear .

[0193] All the above weights and biases are randomly initialized using a normal distribution.

[0194] Initialization is now complete.

[0195] In one embodiment, step S900, keeping the parameters of the TextCNN autoencoder module unchanged, and using the output of the TextCNN autoencoder module as the input of the convolutional network to train the convolutional network module of the fault diagnosis model separately, includes:

[0196] With the parameters of the TextCNN autoencoder module fixed, the output of the TextCNN autoencoder module is used as the input of the convolutional network. The parameters of the convolutional network are adjusted to minimize the error between the fault category prediction result output by the convolutional network and the actual fault category probability, thus obtaining the trained convolutional network module.

[0197] The reason for keeping the parameters of the TextCNN autoencoder module constant is to maintain the consistency and stability of feature extraction during subsequent convolutional network training. This is because after training, the autoencoder's parameters have learned an effective representation of the data features; changing these parameters could affect the stability of the features and the final performance of the model. Using the output of the TextCNN autoencoder module as input to the convolutional network allows the use of the latent features extracted by the autoencoder. These features contain key information from the original data and have removed redundancy and noise, providing high-quality input data for further feature learning and classification by the convolutional network.

[0198] The output of the TextCNN autoencoder refers to the latent spatial compressed features obtained after the autoencoder processes the input data. These features are a compressed representation of the original data, preserving key information. These features are then used as input to a convolutional network, which uses them for further feature extraction and classification, ultimately outputting a fault category prediction. In this way, the model can automatically learn key features in the data and provide high-quality input data for subsequent fault classification.

[0199] Specifically, the training process of a convolutional network is as follows: Training Steps 11-31:

[0200] Training Step 11: Generate numbers from 1 to length(INPUT) with a common difference of 1, and store them in ascending order using a list variable ids.

[0201] ids=[1,2,3,...,length(INPUT)]

[0202] Here, length(INPUT) refers to the length of the list INPUT.

[0203] Training Step 12: Initialize the variable dx and randomly shuffle the order of the numbers in the list variable ids. This randomization ensures the randomness of the training data, avoids biases during the training of the convolutional network model, and allows the convolutional network to learn from data with various orders, thereby improving the model's generalization ability.

[0204] Training Step 13: Set the variable dx and set its value to 1. By setting the initial value of dx, we prepare for possible iterations or loops in subsequent steps and ensure the smooth progress of the training process.

[0205] Training Step 14: Extract and store the training data. Take out the 32 values ​​from the (dx-1)×32+1th to the dx×32th from the list variable ids, and set a list vector train. dx Store these values ​​into a list vector train dx At this point, we can see that the list variable train dx The length is 32.

[0206] Training Step 15: Generate batch input data, retrieve the INPUT list for the train... dx [1],train dx [2],...,train dx

[32] There are 32 elements in total. A tensor `batch_input` is defined, and these elements are stored in the list variable `batch_input` in the order they are retrieved. Among them, `train`... dx[i] refers to the list train dx The i-th element in the tensor. At this point, the shape and size of the tensor batch_input are (32, 3, 80, 80).

[0207] Training step 16: Perform a convolution operation on batch_input using convolution kernel conv1 to obtain the output tensor output_conv1, i.e.

[0208] output_conv1=conv1(batch_input)

[0209] At this point, the shape and size of the tensor output_conv1 are (32, 15, 80, 80).

[0210] This step is the first convolutional operation in the convolutional network. The output of the autoencoder (let's say batch_input) is used as the input to the convolutional network, and the parameters of the convolutional network are adjusted. Then, training steps 17-21 are performed: multiple convolution and pooling operations are carried out.

[0211] Training Step 17: Perform max pooling on the above results using a MaxPooling operation with a size of 2*2 and a sliding window stride of (2,2) to obtain the output tensor output_maxpool1, i.e., output_maxpool1 = MaxPooling(output_conv1).

[0212] At this point, the shape and size of the tensor output_maxpool1 are (32, 15, 40, 40).

[0213] Training step 18: Perform a convolution operation on output_maxpool1 using convolution kernel conv2 to obtain the output tensor output_conv2, i.e.

[0214] output_conv2=conv2(output_maxpool1)

[0215] At this point, the shape and size of the tensor output_conv2 are (32, 15, 38, 38).

[0216] Training Step 19: Perform max pooling on the above results using a MaxPooling operation with a size of 2*2 and a sliding window stride of (2,2), to obtain the output tensor output_maxpool2, i.e., output_maxpool2 = MaxPooling(output_conv2).

[0217] At this point, the shape and size of the tensor output_maxpool2 are (32, 15, 19, 19).

[0218] Training step 20: Perform a convolution operation on output_maxpool2 using the convolution kernel conv3 to obtain the output tensor output_conv3, i.e.

[0219] output_conv3=conv3(output_maxpool2)

[0220] At this point, the shape and size of the tensor output_conv3 are (32,3,19,19).

[0221] Training step 21: Perform max pooling on the above results using a MaxPooling operation with a size of 2*2 and a sliding window stride of (2,2) to obtain the output tensor output_maxpool3, i.e., output_maxpool3 = MaxPooling(output_conv3).

[0222] At this point, the shape and size of the tensor output_maxpool3 are (32,3,9,9).

[0223] The training steps 17-21 above extract features through multiple convolution and pooling operations, gradually adjusting the parameters of the convolutional network. Then, the network output is adjusted through the following training steps 22-23.

[0224] Training step 22: Change the shape and size of the tensor output_maxpool3 to (32, 243).

[0225] Training Step 23: Perform the operation according to the following formula and method:

[0226] output = output_maxpool3 × W linear +B linear

[0227] The shape and size of the tensor output are (32, class_num).

[0228] Training steps 22-23 adjust the output of the convolutional layer to a format suitable for classification, preparing for the final classification output. Then, training steps 24-28 are used to calculate the loss and perform backpropagation.

[0229] Training step 24: Apply the softmax function to the tensor output in the second dimension to obtain...

[0230] softmax_output=softmax(output)

[0231] Training Step 25: Retrieve the LABEL list train dx [1],train dx [2],...,train dx

[32] There are 32 elements in total. Set a list variable lab and store these elements in the list variable label in the order they are retrieved. At this time, the length of lab is 32. Therefore, lab can be regarded as a tensor with a shape and size of (32,1).

[0232] Training step 26: Using one-hot encoding, expand the tensor lab into a tensor of size (32, label_num) according to the values ​​of its elements.

[0233] Training step 27: Calculate the target average loss value using the cross-entropy loss function on tensor softmax_output and tensor lab. That is, use the cross-entropy loss function to calculate the error between the model prediction result and the true label to evaluate the model performance and provide feedback for model optimization.

[0234]

[0235] Training Step 28: Calculate the partial derivatives of the loss function with respect to each parameter, i.e., the gradients, to determine the direction and magnitude of parameter updates, providing precise guidance for parameter updates. Apply the following formula and operation to W... conv1 B conv1 W conv2 B conv2 W conv3 B conv3 W linear B linear Calculate the gradient.

[0236]

[0237] in, This refers to taking the partial derivatives with respect to all the weight parameters in the convolution kernel conv1. This refers to taking the partial derivatives with respect to all the bias parameters in the convolution kernel conv1. Similarly, other partial derivative operations can be understood.

[0238] Training steps 24-28 calculate the loss and perform backpropagation to adjust the network parameters and minimize the error between the predicted results and the actual labels.

[0239] Training Step 29: Update Network Parameters. Based on the results calculated in Training Step 28, update each weight and bias parameter numerically using the following formula and operation. Specifically, update the weights and bias parameters of the convolutional network using the learning rate (β) based on the calculated gradient. Adjust the model parameters to reduce prediction error and improve prediction accuracy.

[0240]

[0241]

[0242]

[0243]

[0244]

[0245]

[0246]

[0247]

[0248] Where β is the learning rate, which can be changed according to the actual situation, and is generally set to 0.002. W conv1 W conv2 W conv3 This is the weight matrix of the convolutional layer; the weight matrix of each convolutional layer determines how that layer extracts features from the input data. conv1 B conv2 B conv3 W is the bias vector of the convolutional layer, used to adjust the result of the convolution operation to better fit the training data; linear This is the weight matrix of the fully connected layer, used to map the output of the convolutional layer to the final output space, i.e., the fault category; B linear It is the bias vector of the fully connected layer, used to adjust the output of the fully connected layer.

[0249] Training step 30: If the value of (dx+1)×32 is greater than length(INPUT), which represents the amount of data processed in the current iteration, then execute training step 31; otherwise, increment the variable dx by 1 and execute training steps 14 to 30.

[0250] Training step 31: Repeat steps 13 to 30 for a total of 10-20 times.

[0251] Training step 32: At this point, the training system has completed its execution, and the trained convolutional network module is obtained. W... conv1 B conv1 Wconv2 B conv2 W conv3 B conv3 W linear B linear The parameters are saved for later use by the system.

[0252] By training steps 30-32 through the above steps, iterating multiple times, and continuously optimizing the model parameters, we finally obtain the trained convolutional network module. The parameters are then saved for later use, allowing the model to perform better on the training data.

[0253] After the convolutional network is trained, the learned parameters are stored so that they can be directly loaded and used in real-world fault diagnosis applications without retraining the model. This facilitates rapid deployment and application of the model, ensuring that the fault diagnosis model can perform fault diagnosis quickly and accurately in real-world environments.

[0254] At this point, the fault diagnosis model training is complete.

[0255] This application also provides an electronic device, which may include a processor and a memory for storing processor-executable instructions, wherein the processor is configured to implement the steps of the fault diagnosis method for the bearing of the fire fan of any of the above embodiments.

[0256] This application also provides a computer-readable storage medium storing a computer program that can be executed by a processor to perform the fault diagnosis method for the bearing of the fire-fighting fan in any of the above embodiments.

[0257] This application also provides a computer program product, including a computer program / instruction, which, when executed by a processor, implements the fault diagnosis method for the bearing of the fire-fighting fan in any of the above embodiments.

[0258] In the several embodiments provided in this application, it should be understood that the disclosed devices and methods can also be implemented in other ways. The device embodiments described above are merely illustrative.

[0259] If a function is implemented as a software module and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk.

[0260] The above are merely embodiments of this application and are not intended to limit the scope of protection of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of protection of this application.

[0261] The above are merely specific embodiments of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A method for diagnosing faults in the bearings of a fire-fighting fan, characterized in that, include: Obtain vibration data of the bearing in the X, Y, and Z axes within a preset time period; For each direction, the vibration data within a preset time period in that direction are converted into a two-dimensional feature map; The two-dimensional feature maps corresponding to each direction are concatenated to obtain a three-channel input tensor; The three-channel input tensor is input into the TextCNN autoencoder module of the trained fault diagnosis model to obtain the latent spatial compression features of the three-channel input tensor. The latent spatial compression features are input into the convolutional network module of the fault diagnosis model to obtain the fault category prediction result output by the convolutional network module.

2. The method according to claim 1, characterized in that, The step of converting vibration data within a preset time period in the direction into a two-dimensional feature map includes: The vibration data is slidably divided into multiple time-domain subsequences of equal length; The multiple time-domain subsequences are arranged sequentially in matrix form to obtain the two-dimensional feature map.

3. The method according to claim 1, characterized in that, The step of concatenating the two-dimensional feature maps corresponding to each direction to obtain a three-channel input tensor includes: The two-dimensional feature map corresponding to each direction is used as data for one channel. The two-dimensional feature maps of the X-axis, Y-axis and Z-axis are arranged in order to obtain the three-channel input tensor.

4. The method according to claim 1, characterized in that, The preset time period is one time window within a fixed time period, and the method further includes: Vibration data from different time windows are acquired multiple times using a sliding window approach to obtain multiple window data. For each window of data, the window data is input into the fault diagnosis model to obtain the fault category prediction result, which includes the probability value corresponding to each fault category. For each fault category, the probability values ​​corresponding to the fault category in different window data are summed to obtain the comprehensive probability corresponding to each fault category; The overall probability corresponding to each fault category is normalized, and the fault category corresponding to the maximum probability is selected as the final fault category identification result.

5. The method according to claim 1, characterized in that, Before inputting the three-channel input tensor into the TextCNN autoencoder module of the trained fault diagnosis model to obtain the latent space compression features of the three-channel input tensor, the method further includes: Obtain three-dimensional sample data containing different fault categories; The three-dimensional sample data is converted into two-dimensional feature maps along the X-axis, Y-axis, and Z-axis. The X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map are used as inputs to the TextCNN autoencoder, and the TextCNN autoencoder module of the fault diagnosis model is trained separately. With the parameters of the TextCNN autoencoder module fixed, the output of the TextCNN autoencoder module is used as the input of the convolutional network to train the convolutional network module of the fault diagnosis model separately.

6. The method according to claim 5, characterized in that, The TextCNN autoencoder module, which uses the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map as input to the TextCNN autoencoder and trains them separately to obtain the fault diagnosis model, includes: The X-axis two-dimensional feature map, Y-axis two-dimensional feature map and Z-axis two-dimensional feature map are processed by TextCNN autoencoder and fully connected layer respectively to obtain the X-axis extraction result, Y-axis extraction result and Z-axis extraction result; The parameters of the TextCNN autoencoder are adjusted to minimize the differences between the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map and the X-axis extraction result, Y-axis extraction result, and Z-axis extraction result, thus obtaining the TextCNN autoencoder module of the trained fault diagnosis model.

7. The method according to claim 5, characterized in that, The method of fixing the parameters of the TextCNN autoencoder module and using its output as the input to the convolutional network to train the convolutional network module of the fault diagnosis model separately includes: With the parameters of the TextCNN autoencoder module fixed, the output of the TextCNN autoencoder module is used as the input of the convolutional network. The parameters of the convolutional network are adjusted to minimize the error between the fault category prediction result output by the convolutional network and the actual fault category probability, thus obtaining the trained convolutional network module.

8. The method according to claim 6, characterized in that, The process of processing the X-axis two-dimensional feature map, Y-axis two-dimensional feature map, and Z-axis two-dimensional feature map through a TextCNN autoencoder and a fully connected layer to obtain the X-axis extraction result, Y-axis extraction result, and Z-axis extraction result includes: The X-axis two-dimensional feature map, Y-axis two-dimensional feature map and Z-axis two-dimensional feature map are respectively input into the TextCNN autoencoder; Multiple sliding kernels of fixed size are set up. The sliding kernels slide along the horizontal and vertical directions on the X-axis two-dimensional feature map, the Y-axis two-dimensional feature map and the Z-axis two-dimensional feature map respectively, and perform matrix multiplication with the corresponding two-dimensional feature map to obtain local features of fixed size. Max pooling is performed on each local feature of a fixed size to obtain the max-pooled features; The max-pooled features are concatenated and mapped through a fully connected layer to obtain the X-axis, Y-axis, and Z-axis extraction results.

9. The method according to claim 5, characterized in that, Before training the convolutional network module of the fault diagnosis model separately by keeping the parameters of the TextCNN autoencoder module unchanged and using the output of the TextCNN autoencoder module as the input of the convolutional network, the method further includes: Randomly initialize the weights and biases of the trainable convolutional kernel.

10. An electronic device, characterized in that, The electronic device includes: processor; Memory used to store processor-executable instructions; The processor is configured to perform the fault diagnosis method for the bearing of the fire-fighting fan as described in any one of claims 1-9.

11. A computer-readable storage medium, characterized in that, The storage medium stores a computer program that can be executed by a processor to perform the fault diagnosis method for the bearing of the fire-fighting fan as described in any one of claims 1-9.

12. A computer program product, characterized in that, Includes a computer program / instruction that, when executed by a processor, implements the fault diagnosis method for the bearing of the fire-fighting fan as described in any one of claims 1-9.

Images