An efficient distributed parallel training method for a fault diagnosis model based on I-PixelHop

Abstract

This invention discloses an efficient distributed parallel training method for a bearing fault diagnosis model based on I-PixelHop. The method divides the bearing fault dataset into multiple DataFrame partitions and distributes them to all Worker nodes. Each Worker node deploys multiple PixelHop units and ILAG units, and launches multiple Spark executors to process all DataFrame partitions assigned to that Worker node in parallel. Within each Worker node, each Spark executor utilizes GPU computing resources to sequentially process each PixelHop unit and ILAG unit in parallel. Meanwhile, in the Master node, local feature vectors from all Worker nodes are concatenated into a global feature vector. Finally, multiple SVM-based bearing fault classifiers are trained in parallel using all Worker nodes and weighted voting is performed. This method solves the problem of long training times in existing lightweight I-PixelHop learning frameworks when computing large-scale bearing fault datasets.

Description

Technical Field

[0001] This invention relates to the field of bearing fault diagnosis technology, and more specifically, to an efficient distributed parallel training method for a fault diagnosis model based on I-PixelHop. Background Technology

[0002] With the rise and development of data-driven fault diagnosis technology, machine learning methods have been widely used in bearing fault diagnosis. However, machine learning-based bearing fault diagnosis methods typically require signal processing techniques to preprocess bearing vibration data, which to some extent limits the practical application effectiveness of machine learning methods in complex industrial production scenarios and big data environments.

[0003] Deep learning methods possess strong feature representation and generalization capabilities, enabling bearing fault diagnosis methods based on deep learning to achieve high diagnostic accuracy under complex operating conditions. However, existing deep learning-based bearing fault diagnosis models are typically large and computationally complex, resulting in low training performance under industrial big data. For example, CN202210113860.0, "A Method for Constructing and Applying a Bearing Fault Diagnosis Model under Variable Operating Conditions," constructs a bearing fault diagnosis model under variable operating conditions that includes a feature extraction module, a generation module, a domain classifier, and a label classifier. By combining the three components of a label classifier, a domain classifier, and a generation module, additional training data can be effectively generated. While ensuring that the domain classifier can acquire discriminative features within the domain, the domain discrimination loss is maximized to reduce its domain sensitivity to different data, making it difficult for the domain classifier to distinguish these data. In turn, this enables the feature extraction module to extract more domain-independent temporal features, achieving end-to-end joint training. After continuously training the model, the label classifier is refined as much as possible, and the domain classifier is generalized as much as possible, thereby improving the model's generalization ability for working conditions of unseen bearings. This allows the fault diagnosis model to accurately determine the fault type under different working conditions.

[0004] I-PixelHop is a lightweight learning framework based on continuous subspace learning. Compared with deep learning methods, bearing fault diagnosis models based on I-PixelHop have lower computational complexity and smaller model size. I-PixelHop addresses the problem of excessive reliance on prior knowledge through cross-entropy thresholding and solves the problem of poor feature reusability by employing a pseudo-dense connection structure, achieving high bearing fault diagnosis accuracy. However, due to the large number of matrix operations required for processing PixelHop units and ILAG units in I-PixelHop, the training time for bearing fault diagnosis models based on I-PixelHop remains relatively long when dealing with large-scale bearing fault datasets. Summary of the Invention

[0005] The main technical problem to be solved by this invention is that the existing technology using the I-PixelHop lightweight learning framework has a long training time when calculating large-scale bearing fault datasets. This invention provides an efficient distributed parallel training method for fault diagnosis models based on I-PixelHop.

[0006] The objective of this invention is achieved through the following technical solution:

[0007] An efficient distributed parallel training method for a fault diagnosis model based on I-PixelHop includes the following steps:

[0008] S1. Preprocess the fault dataset;

[0009] S2. Divide the preprocessed fault dataset into P DataFrame partitions and assign them to K Worker nodes. Assign each Z PixelHop unit and ILAG unit in I-PixeHop to K Worker nodes. The i-th Worker node is assigned hi PixelHop units and ILAG units.

[0010] S3. In the i-th Worker node, use ni Spark executors to process the mi DataFrame partitions assigned to the Worker node in parallel. The Spark executors take the d-th DataFrame partition DFPi.jd as the input of the first PixelHop unit of the Worker node, and process the x-th PixelHop unit and ILAG unit in the Worker node in parallel.

[0011] S4. Repeat step S3 until the Worker node has processed all PixelHop and ILAG units, and the Spark executor has processed all mij DataFrame partitions assigned to it;

[0012] S5. The probability vectors generated by the ILAG unit are concatenated into local feature vectors, and then the Worker node concatenates the local feature vectors into a global feature vector;

[0013] S6. Use Worker nodes to train multiple SVM-based fault classifiers in parallel and perform weighted voting.

[0014] Furthermore, the preprocessing includes converting the one-dimensional vibration signal into a two-dimensional image.

[0015] Furthermore, the kernel matrix in the Saab transform filter of the PixelHop unit in S2 is randomly initialized.

[0016] Furthermore, the parallel processing steps of the PixelHop unit in S3 include: first, performing neighborhood expansion and Saab transformation on the input data in the PixelHop unit to generate an intermediate feature map; then, performing non-overlapping spatial pooling on the generated intermediate feature map; and finally, passing the intermediate feature map after the pooling operation to the ILAG unit connected to the PixelHop unit and all subsequent PixelHop units in the Worker node.

[0017] Furthermore, the parallel processing steps of the ILAG unit in S3 include: converting the received intermediate feature map into a one-dimensional attribute vector, clustering the one-dimensional attribute vector using the Bi-K-Means clustering algorithm to generate several cluster centers, calculating the likelihood between each attribute vector and each cluster center, and generating a probability vector based on the likelihood.

[0018] Furthermore, the probability vector is also optimized and adjusted using the cross-entropy thresholding method.

[0019] Furthermore, the specific steps of parallel training in S6 include:

[0020] S61. In the Master node, the global feature vector is divided into multiple DataFrame partitions and automatically assigned to all Spark executors in the K Worker nodes;

[0021] S62. Each Spark executor in each Worker node takes one DataFrame partition at a time from all the DataFrame partitions allocated to it and calls GPU computing resources to train the v-th SVM-based fault classifier in parallel, where 1≤v≤N;

[0022] S63. Continuously execute the training of the SVM-based fault classifier until the training of N SVM-based fault classifiers is completed;

[0023] S64. A weighted vote is performed on the classification results of N SVM-based fault classifiers to obtain an ensemble classifier.

[0024] Furthermore, the calculation formula used by S64 is as follows:

[0025]

[0026] In the formula, C represents the number of fault categories, and N represents the number of SVM-based fault classifiers. This indicates that the k-th SVM-based fault classifier predicts the fault category of feature vector f as fault category c. i The probability, This means predicting the fault category as c for feature vector f. i The weight of the k-th SVM-based fault classifier.

[0027] Furthermore, the aforementioned The calculation formula is:

[0028]

[0029] in, This indicates that the k-th SVM-based fault classifier classifies the true fault category as c. i The feature vector f is predicted as the fault category c. i The probability of.

[0030] Furthermore, the efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop is characterized in that the training method is used for bearing fault diagnosis.

[0031] Compared with existing technologies, the beneficial effects are:

[0032] This invention provides an efficient distributed parallel training method for bearing fault diagnosis models based on I-PixelHop. By making full use of multiple worker nodes in the Spark-GPU cluster and the GPU computing resources within each worker node, distributed parallel training is performed efficiently, significantly improving the training performance of I-PixelHop-based bearing fault diagnosis models on large-scale bearing fault datasets.

[0033] This invention enables the concurrent execution of multiple independent instructions within each clock cycle, compiling and executing multiple instructions in a parallel manner. This achieves asynchronous parallel execution of the PixelHop and ILAG units, significantly reducing the idle waiting time of each functional unit in I-PixelHop. Furthermore, this invention employs a weighted voting method to combine multiple SVM-based fault classifiers into an ensemble classifier, effectively improving the diagnostic accuracy of the I-PixelHop-based bearing fault diagnosis model under industrial big data. Attached Figure Description

[0034] Figure 1 This is a schematic diagram of the distributed parallel training of the bearing fault diagnosis model based on I-PixelHop under the Spark-GPU cluster in Example 1.

[0035] Figure 2This is a comparison chart of the training performance of the bearing fault diagnosis model based on I-PixelHop in Example 2 under Spark-GPU clusters with different numbers of Worker nodes.

[0036] Figure 3 This is a diagram of the bearing fault diagnosis model based on serial I-PixelHop in Example 3;

[0037] Figure 4 This is a diagram of the asynchronous parallel execution strategy based on superscalar pipeline in Example 3. Detailed Implementation

[0038] The following examples further explain and clarify the invention, but the specific examples do not limit the invention in any way.

[0039] Example

[0040] like Figure 1 This embodiment provides an efficient distributed parallel training method for a bearing fault diagnosis model based on I-PixelHop. The specific steps are as follows:

[0041] S1. In the Master node of the Spark-GPU cluster, randomly initialize the kernel matrix in the Saab transform filter of each PixelHop unit in I-PixeHop.

[0042] S2. Based on the processing capabilities of all K available Worker nodes in the Spark-GPU cluster, the Spark session object is invoked in the Master node to divide the bearing failure dataset stored in HDFS into P DataFrame partitions and allocate them appropriately to the K Worker nodes. The i-th Worker node is assigned to m... i A DataFrame partition, where 1 ≤ i ≤ K, m i ≥1 and

[0043] S3. Based on the processing capabilities of all K available Worker nodes in the Spark-GPU cluster, the Spark session object is invoked in the Master node to reasonably allocate all Z PixelHop units and ILAG units in I-PixeHop to the K Worker nodes. The i-th Worker node is allocated to each hi PixelHop unit and ILAG unit, where 1≤i≤K, h i ≥1 and

[0044] S4. Start ni Spark executors in the i-th Worker node to process the mi DataFrame partitions assigned to that node in parallel.

[0045] S5. The j-th Spark executor in the i-th Worker node processes the mij DataFrame partitions assigned to it sequentially. Where 1≤i≤K, 1jn i m ij ≥1 and

[0046] S6. The j-th Spark executor in the i-th Worker node takes the d-th DataFrame partition DFPi.jd assigned to it as the input of the first PixelHop unit of that Worker node, where 1≤i≤K and 1≤j≤n. i And 1≤d≤m ij .

[0047] S7: The j-th Spark executor in the i-th Worker node calls upon GPU computing resources to process the x-th PixelHop unit in that Worker node in parallel, where 1≤x≤h i .

[0048] S7.1: Perform neighborhood expansion and Saab transformation on the input data of the x-th PixelHop unit to generate an intermediate feature map.

[0049] S7.2: Perform non-overlapping spatial pooling on the intermediate feature map generated by the x-th PixelHop unit.

[0050] S7.3: Pass the intermediate feature map after the pooling operation is completed to the ILAG unit connected to the x-th PixelHop unit and all subsequent PixelHop units in the i-th Worker node. If x = h i Then, the intermediate feature map generated after processing the xth PixelHop unit is sent to the Master node, and the Master node then sends it to all subsequent Worker nodes.

[0051] S8: The j-th Spark executor in the i-th Worker node calls upon GPU computing resources to process the x-th ILAG unit in that Worker node in parallel, where 1≤x≤h. i .

[0052] S8.1: Straighten the intermediate feature map received by the x-th ILAG unit into a one-dimensional attribute vector.

[0053] S8.2: Use the Bi-K-Means clustering algorithm to cluster one-dimensional attribute vectors and generate several cluster centers.

[0054] S8.3: Calculate the likelihood between each attribute vector and each cluster center, and generate a probability vector based on the likelihood.

[0055] S8.4: Use the cross-entropy thresholding method to optimize and adjust the generated probability vector.

[0056] S9: Repeat steps 7 and 8 until the j-th Spark executor in the i-th Worker node has finished processing all PixelHop and ILAG units in that Worker node.

[0057] S10: Repeat steps 6 to 9 until the j-th Spark executor in the i-th Worker node has finished processing all mij DataFrame partitions assigned to it.

[0058] S11: Concatenate the probability vectors generated by all Spark executors in each Worker node after processing all ILAG units in that Worker node into a local feature vector, and send it to the Master node.

[0059] S12: In the Master node, the local feature vectors from all K Worker nodes are concatenated into a global feature vector.

[0060] S13: Use K worker nodes to train N SVM-based fault classifiers in parallel.

[0061] S13.1: In the Master node, the global feature vector is divided into multiple DataFrame partitions and automatically assigned to all Spark executors in the K Worker nodes.

[0062] S13.2: Each Spark executor in each Worker node takes one DataFrame partition at a time from all the DataFrame partitions allocated to it and calls GPU computing resources to train the v-th SVM-based fault classifier in parallel, where 1≤v≤N.

[0063] S13.3: Continuously execute the training of SVM-based fault classifiers until the training of N SVM-based fault classifiers is completed.

[0064] S13.4: An ensemble classifier is obtained by weighting the classification results of N SVM-based fault classifiers according to the following formula:

[0065]

[0066] Where C represents the number of bearing fault categories, and N represents the number of SVM-based fault classifiers. This indicates that the k-th SVM-based fault classifier predicts the fault category of feature vector f as fault category c. i The probability, This means predicting the fault category as c for feature vector f. i The weight of the k-th SVM-based fault classifier is calculated using the following formula.

[0067]

[0068] in, This indicates that the k-th SVM-based fault classifier classifies the true fault category as c. i The feature vector f is predicted as the fault category c. i The probability of.

[0069] Example 2

[0070] This embodiment, based on the method described in Embodiment 1, conducts simulation experiments on a large-scale CWRU bearing fault dataset in a Spark-GPU cluster with one Master node and four Worker nodes. The three enhanced CWRU bearing fault datasets used are shown below:

[0071] The dataset DS-I is 8.2 GB in size;

[0072] The dataset DS-II is 12.8 GB in size;

[0073] The dataset DS-III is 24.0 GB in size.

[0074] The diagnostic results are shown in Table 1:

[0075] Table 1

[0076] Bearing Fault Dataset Fault diagnosis accuracy DS-I 98.31％ DS-II 98.86％ DS-III 98.96％ Average diagnostic accuracy 98.71％

[0077] As shown in Table 1, the efficient distributed parallel training method for bearing fault diagnosis model based on I-PixelHop provided by this invention can guarantee a high bearing fault diagnosis accuracy, achieving an average diagnosis accuracy of 98.71% on three different sizes of large-scale bearing fault datasets.

[0078] The time consumed in parallel training of an I-PixelHop-based bearing fault diagnosis model on a Spark-GPU cluster with varying numbers of worker nodes for a 24.0GB large-scale bearing fault dataset. Figure 2 As shown, in the Spark-GPU cluster, compared with using a single Worker node to perform parallel training of the bearing fault diagnosis model based on I-PixelHop, using four Worker nodes to perform distributed parallel training of the bearing fault diagnosis model based on I-PixelHop reduces the time by 71.51% and achieves a speedup of 3.51 times.

[0079] Example 3

[0080] This implementation compares a bearing fault diagnosis model based on distributed parallel I-PixelHop with a bearing fault diagnosis model based on serial I-PixelHop, wherein the bearing fault diagnosis model based on serial I-PixelHop is as follows: Figure 3 As shown in Table 2, the comparison results are as follows:

[0081] Table 2

[0082]

[0083] In the distributed parallel I-PixelHop framework, the input of each PixelHop unit can be divided into λ blocks. Within each PixelHop unit, the same PixelHop Operation (PHO) is used to process each block sequentially. For the first PixelHop unit, the intermediate feature map generated after processing the j-th block of that PixelHop unit is passed to the ILAG unit connected to it and to all subsequent PixelHop units, where 1≤j≤λ.

[0084] For the i-th PixelHop unit (i≥2), firstly, after receiving the intermediate feature maps generated from the processing of the j-th blocks of all previous PixelHop units, it performs a superposition operation on these intermediate feature maps and uses them as its j-th block. Then, it processes the j-th block in the i-th PixelHop unit and passes the intermediate feature map generated after processing the j-th block to the ILAG unit connected to the i-th PixelHop unit and all subsequent PixelHop units.

[0085] For the last PixelHop unit, after processing the j-th block, it simply passes the generated intermediate feature map to the ILAG unit connected to it. The total time required for the asynchronous parallel processing of h PixelHop units and h ILAG units is...

[0086]

[0087] Where λ represents the number of blocks in each PixelHop unit and ILAG unit.

[0088] like Figure 4 Assuming the input of each PixelHop unit can be divided into four blocks (meaning processing one PixelHop unit requires four PixelHop operations) and each PixelHop operation takes one clock cycle T, processing four PixelHop units would take 16T if a synchronous serial execution method is used; however, processing four PixelHop units would only take 7T if an asynchronous parallel execution method based on superscalar pipelines is used. Therefore, adopting an asynchronous parallel execution strategy based on superscalar pipelines allows multiple functional units to execute asynchronously in parallel, significantly reducing the idle waiting time of each functional unit. This is especially true when the input data size is large, significantly improving the execution efficiency of the I-PixelHop framework.

[0089] As shown in Table 2, in the distributed parallel and serial I-PixelHop bearing fault diagnosis models, on the three large-scale bearing fault datasets DS-I, DS-II, and DS-III, the model training time obtained by using the distributed parallel I-PixelHop bearing fault diagnosis model under the Spark-GPU cluster is reduced by 98.84%, 99.10%, and 99.13%, respectively, compared with the bearing fault diagnosis model based on serial I-PixelHop.

[0090] Obviously, the above embodiments of the present invention are merely examples for clearly illustrating the present invention, and are not intended to limit the implementation of the present invention. Those skilled in the art can make other variations or modifications based on the above description. It is neither necessary nor possible to exhaustively describe all embodiments here. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention should be included within the scope of protection of the claims of the present invention.

Claims

1. An efficient distributed parallel training method for a fault diagnosis model based on I-PixelHop, characterized in that, Includes the following steps: S1. Preprocess the fault dataset; S2. Divide the preprocessed fault dataset into P DataFrame partitions and distribute them to K Worker nodes. Distribute each of the Z PixelHop units and ILAG units in I-PixeHop to the K Worker nodes. The i-th Worker node is allocated h... i One PixelHop unit and one ILAG unit; S3. Use n in the i-th Worker node i Each Spark executor processes m tasks assigned to the Worker node in parallel. i For each DataFrame partition, Spark executors will partition the d-th DataFrame partition (DFP). i.j.d As input to the first PixelHop unit of the Worker node, and to the xth PixelHop unit and ILAG unit in the Worker node are processed in parallel; S4. Repeat step S3 until the Worker node has processed all PixelHop and ILAG units, and the Spark executor has processed all the m units assigned to it. ij Up to one DataFrame partition; S5. The probability vectors generated by the ILAG unit are concatenated into local feature vectors, and then the Worker node concatenates the local feature vectors into a global feature vector; S6. Use Worker nodes to train multiple SVM-based fault classifiers in parallel and perform weighted voting.

2. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to claim 1, characterized in that, The preprocessing includes converting the one-dimensional vibration signal into a two-dimensional image.

3. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to claim 1, characterized in that, The kernel matrix in the Saab transform filter of the PixelHop unit in S2 is randomly initialized.

4. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to claim 1, characterized in that, The parallel processing steps of the PixelHop unit in S3 include: first, performing neighborhood expansion and Saab transformation on the input data in the PixelHop unit to generate an intermediate feature map; then, performing non-overlapping spatial pooling on the generated intermediate feature map; and finally, passing the intermediate feature map after the pooling operation to the ILAG unit connected to the PixelHop unit and all subsequent PixelHop units in the Worker node.

5. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to claim 1, characterized in that, The parallel processing steps of the ILAG unit in S3 include: converting the received intermediate feature map into a one-dimensional attribute vector, using the Bi-K-Means clustering algorithm to cluster the one-dimensional attribute vector to generate several cluster centers, calculating the likelihood between each attribute vector and each cluster center, and generating a probability vector based on the likelihood.

6. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to claim 5, characterized in that, The probability vector is further optimized and adjusted using the cross-entropy thresholding method.

7. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to claim 1, characterized in that, The specific steps of parallel training in S6 include: S61. In the Master node, the global feature vector is divided into multiple DataFrame partitions and automatically assigned to all Spark executors in the K Worker nodes; S62. Each Spark executor in each Worker node takes one DataFrame partition at a time from all the DataFrame partitions allocated to it and calls GPU computing resources to train the v-th SVM-based fault classifier in parallel, where 1≤v≤N; S63. Continuously execute the training of the SVM-based fault classifier until the training of N SVM-based fault classifiers is completed; S64. A weighted vote is performed on the classification results of N SVM-based fault classifiers to obtain an ensemble classifier.

8. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to claim 7, characterized in that, The calculation formula used by S64 is: In the formula, C represents the number of fault categories, and N represents the number of SVM-based fault classifiers. This indicates that the k-th SVM-based fault classifier predicts the fault category of feature vector f as fault category c. i The probability, This means predicting the fault category as c for feature vector f. i The weight of the k-th SVM-based fault classifier.

9. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to claim 8, characterized in that, The The calculation formula is: in, This indicates that the k-th SVM-based fault classifier classifies the true fault category as c. i The feature vector f is predicted as the fault category c. i The probability of.

10. The efficient distributed parallel training method for the fault diagnosis model based on I-PixelHop according to any one of claims 1-9, characterized in that, The training method is used for bearing fault diagnosis.

Images