Rotating machinery intelligent diagnosis method based on structured pruning and knowledge fusion distillation

Abstract

The invention discloses a rotating machine intelligent diagnosis method based on structured pruning and knowledge fusion distillation, and the method comprises the steps: training a teacher network through a training set, carrying out the structured pruning of a percentile threshold value on the teacher network based on the L2 norm calculation and normalization of a convolution filter, and generating a student network with a consistent structure. A KFD strategy including feature-level distillation and logit-level distillation is utilized to carry out deep supervision on a student network, and two types of distillation losses are weighted and fused, so that a student model still keeps relatively strong feature characterization capability and category discrimination capability under a high pruning rate. Asymmetric integer quantization is adopted for the trained student network, so that the reasoning overhead is reduced, and the embedded adaptability is improved. A general neural network operator IP core is arranged on an FPGA, efficient deployment of a quantitative student model is achieved, and low-power-consumption and low-delay real-time fault diagnosis is achieved. The method has the advantages of being high in precision, light in model weight, easy to deploy and the like, and is suitable for on-line monitoring of industrial field rotating machinery.

Description

Technical Field

[0001] This invention relates to the field of fault diagnosis technology, specifically to an intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation. Background Technology

[0002] Rotating machinery, such as electric motors, pumps, and fans, plays a crucial role in driving and transmitting power in various industrial systems. Among these, rolling bearings, as vital load-bearing and support components, directly impact the overall stability and safety of the equipment. Studies show that bearings are among the most prone to failure in rotating equipment, and their malfunctions can lead to production downtime, equipment damage, and even serious safety accidents. Therefore, efficient rolling bearing fault monitoring can significantly extend the service life of rotating machinery and reduce associated economic losses.

[0003] With the rapid development of deep learning (DL), DL-based intelligent diagnostic methods have achieved great success. Traditional deep learning network architectures, such as Long Short-Term Memory (LSTM) networks, deep residual networks, and one-dimensional convolutional neural networks, have been widely applied to intelligent fault diagnosis of mechanical equipment. Recent research has mainly focused on improving model performance by increasing the depth and complexity of deep learning networks. However, these large-scale intelligent diagnostic models typically require high-performance computers or servers to run effectively. Factories often have multiple rotating machines, and equipping each machine with a dedicated high-performance workstation or computing platform to deploy large-scale fault diagnosis models not only leads to inefficient use of space resources but also poses significant challenges in terms of energy consumption and power management. In fact, FPGAs, as low-power, highly parallel portable computing platforms, have been widely used to accelerate the inference of deep learning models. Compared with CPUs and GPUs, FPGAs are more suitable for resource-constrained and latency-sensitive industrial scenarios. Their high energy efficiency and real-time computing capabilities have significant advantages in intelligent diagnostic tasks. However, due to limitations in on-chip resources and memory bandwidth, FPGAs often struggle to effectively support the deployment of large-scale deep neural networks. Therefore, there is an urgent need to design compact, high-performance, lightweight diagnostic models to meet deployment requirements in resource-constrained environments. It is well known that deep learning models have significant redundancy in terms of parameters and feature channels, much of which contributes negligibly to classification accuracy. Therefore, model compression is crucial for reducing computational overhead without significantly sacrificing performance. Currently, mainstream compression methods for deep learning models are generally divided into three categories: model pruning, parameter quantization, and KD (Knowledge-Demand Digest). Model pruning removes less important weights or filters, achieving efficient compression with minimal performance loss. Generally, pruning rates below 30% do not significantly affect model performance. However, for large-scale networks like VGG with over 130 million parameters, a 30% pruning rate only produces limited compression effects; therefore, achieving a high pruning rate without sacrificing performance is a key issue. KD utilizes a teacher-student paradigm to transfer knowledge from a larger model to a smaller one. KD methods are generally divided into logit-based and feature-based methods. However, existing methods often suffer from significant architectural differences between the teacher and student networks, limiting the effectiveness of knowledge transfer. In summary, three key challenges need to be addressed: (1) designing a student network with a similar structure to the teacher network to improve distillation efficiency; (2) significantly improving the pruning rate to achieve a higher model compression rate while maintaining high model performance; and (3) developing an efficient FPGA deployment strategy to meet the industrial-grade requirements of low power consumption and flexible deployment. Summary of the Invention

[0004] In view of the above-mentioned problems, the present invention is proposed.

[0005] To address the aforementioned technical problems, this invention provides the following technical solution: a method for intelligent diagnosis of rotating machinery based on structured pruning and knowledge fusion distillation, comprising:

[0006] By conducting vibration test experiments on typical bearing faults in rotating machinery, vibration acceleration signals under typical fault conditions are collected.

[0007] The collected vibration signals were divided into training set, validation set and test set according to time sequence, and the teacher network was trained using the training set.

[0008] The convolutional filter of the teacher neural network is calculated and normalized according to the L2 norm, and structured pruning is performed according to the percentile threshold to obtain the student neural network.

[0009] A KFD strategy is constructed to train a student network, and the parameters of the trained student network are subjected to asymmetric integer quantization. The KFD strategy includes a feature-level distillation module and a logit-level distillation module. The training process of the student model is optimized by weighted fusion of the loss of the feature-level distillation module and the loss of the logit-level distillation module.

[0010] A general-purpose neural network operator IP core is deployed on each FPGA to deploy a quantized lightweight student model for real-time fault diagnosis.

[0011] As a preferred embodiment of the intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation described in this invention, the typical fault states include: healthy state, outer ring fault, inner ring fault, rolling element fault, and compound fault.

[0012] As a preferred embodiment of the intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation described in this invention, wherein: after the training of the teacher network is completed, the pruning of the filter is identified using an initialized mask matrix;

[0013] For each filter corresponding to each convolutional kernel in each convolutional layer, the L2 norm is calculated; the L2 norm of all filters in the layer is normalized to measure the importance of different filters.

[0014] In each layer, the L2 norm of each filter is arranged in ascending order, and the front end of the sequence is pruned according to the pruning rate R. The pruned filters are assigned a value of 0 in the mask matrix M, indicating that the filter has been pruned and will not participate in subsequent calculations; the unpruned filters are assigned a value of 1 in the mask matrix, indicating that the filter is retained.

[0015] Repeat the pruning process until the target pruning rate is achieved;

[0016] Each time the pruning rate increases by 1%, the teacher network is retrained to recover the accuracy loss caused by pruning;

[0017] After the pruning operation is completed, the network is reconstructed into a student network based on the number of filters remaining in each pruned layer.

[0018] As a preferred embodiment of the intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation described in this invention, wherein: in the logit-level distillation module, soft tags are generated based on the logits output by the teacher network, using the softmax function and combined with the distillation temperature T;

[0019]

[0020] in, is a soft label representing the probability of the i-th category; T represents the distillation temperature as a positive real number; Let represent the raw score output by the teacher network for category i without softmax processing; Q represents the number of categories; q represents the category index, q∈Q;

[0021] KL divergence is used to measure the similarity between the output label probabilities of the student and teacher networks; the loss represents the target knowledge.

[0022]

[0023] in, Represents the divergence loss function; This represents the probability distribution of soft labels in the teacher's network output; This represents the probability distribution of soft labels in the student's network output.

[0024] As a preferred embodiment of the intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation described in this invention, the feature-level distillation module includes simplifying the process of aligning the feature layers of the teacher network and the student network when the intermediate feature knowledge output by the teacher network helps train the student network:

[0025] By introducing bridge connections, the matching of feature maps output by teachers and students in the network is facilitated, thereby simplifying the feature map matching process of layer-by-layer alignment.

[0026] The bridge connection is achieved through transposed convolution kernels; let the output feature map of the teacher network be... The output feature map of the student network is ;

[0027] Expanded student feature map:

[0028]

[0029] Where K represents the shape as convolution kernel, and These represent the size of the convolution kernel in the height and width directions, respectively; The number of channels representing the teacher's feature map; The number of channels in the student feature map; Indicates the height of the teacher feature map; Indicates the height of the student feature map; Indicates the width of the teacher feature map; Show the width of the student feature map; This indicates the transpose convolution operation;

[0030] The similarity between the feature map outputs of the last layer of the model is measured using mean squared error loss.

[0031]

[0032] Where n represents the number of samples, and b represents the sample index. This represents the teacher feature map of the b-th sample. This represents the expanded student feature map of the b-th sample. This represents the result of subtracting corresponding elements one by one.

[0033] Through Introduced in China ,make and Keep it on an order of magnitude; minimize the loss of the characteristic distillation module. And the loss of the logit-level distillation module Multiply The result, after weighted fusion, yields the fusion loss;

[0034] The complete KFD loss function is obtained by weighting and fusing the fusion loss with the cross-entropy loss function of the student network.

[0035] As a preferred embodiment of the intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation described in this invention, the asymmetric quantization includes quantizing the parameters of each layer of the student network and then simplifying the number of floating points.

[0036]

[0037]

[0038]

[0039] in, and These represent the maximum and minimum values ​​of the parameter to be quantized, respectively. and The maximum and minimum values ​​of the quantization interval are represented by [0, 255]; S is the scaling factor, representing the mapping ratio from floating-point to integer; Z is the zero offset; and q is the parameter for the final quantization. This indicates taking the nearest integer.

[0040] As a preferred embodiment of the intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation described in this invention, the neural network operator IP core is a student model that completes the asymmetric quantization.

[0041] A rotating machinery intelligent diagnostic system based on structured pruning and knowledge fusion distillation using the method described in this invention, wherein: the acquisition unit acquires vibration acceleration signals under typical fault conditions by conducting vibration test experiments on typical bearing faults in rotating machinery;

[0042] The training unit divides the collected vibration signals into training, validation, and test sets according to time sequence, and uses the training set to train the teacher network.

[0043] The learning unit calculates and normalizes the convolutional filters of the teacher neural network according to the L2 norm, performs structured pruning based on percentile thresholds, and obtains the student neural network. A KFD strategy is constructed to train the student network, and the parameters of the trained student network are asymmetric integer quantized. The KFD strategy includes a feature-level distillation module and a logit-level distillation module. The training process of the student model is optimized by weighted fusion of the losses from the feature-level distillation module and the logit-level distillation module.

[0044] The deployment unit arranges common neural network operator IP cores on each FPGA to deploy quantized lightweight student models for real-time fault diagnosis.

[0045] A computer device includes: a memory and a processor; the memory stores a computer program, wherein: when the processor executes the computer program, it implements the steps of the method described in any one of the present invention.

[0046] A computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of the method described in any one of the present invention.

[0047] The beneficial effects of this invention are as follows: This invention constructs a lightweight intelligent diagnostic model that simultaneously possesses high accuracy, high compression ratio, and strong deployability through a collaborative design of structured pruning, knowledge fusion distillation, and asymmetric quantization. First, by progressively pruning the convolutional filters of the teacher network using structured pruning, the number of model parameters and computational load are significantly reduced while maintaining the consistency of the teacher-student network structure, laying the foundation for efficient distillation. Based on this, the feature-level and logit-level fusion distillation strategy proposed in this invention enables the student network to simultaneously inherit the deep feature representation capabilities and category discrimination information of the teacher network, effectively compensating for the performance degradation caused by the high pruning rate and significantly improving the robustness and generalization ability of the model under complex conditions such as variable speed and strong noise. Subsequently, an asymmetric 8-bit quantization method is used to further compress the model's storage size, making the model more suitable for the integer computation characteristics of FPGA while maintaining accuracy. Finally, this invention constructs a general-purpose neural network operator IP core on the FPGA and utilizes AXI and DMA mechanisms to achieve efficient data transmission, enabling the quantized model to complete real-time inference with low power consumption and low latency. Attached Figure Description

[0048] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0049] Figure 1 The overall flowchart of an intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation is provided for the first embodiment of the present invention;

[0050] Figure 2 The diagram illustrates the influence of pruning rate on model performance in a rotating machinery intelligent diagnostic method based on structured pruning and knowledge fusion distillation, as provided in the second embodiment of the present invention. Detailed Implementation

[0051] To make the above-mentioned objects, features, and advantages of the present invention more apparent and understandable, specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the protection scope of the present invention.

[0052] Example 1, referring to Figure 1 As an embodiment of the present invention, a method for intelligent diagnosis of rotating machinery based on structured pruning and knowledge fusion distillation is provided, comprising:

[0053] S1: By conducting vibration test experiments on typical bearing faults in rotating machinery, vibration acceleration signals under typical fault conditions are collected.

[0054] Furthermore, the bearing acceleration signal includes vibration acceleration signals under various typical fault conditions such as healthy condition, outer ring fault, inner ring fault, rolling element fault, and combined fault.

[0055] S2: Divide the collected vibration signals into training set, validation set and test set according to time sequence, and use the training set to train the teacher network.

[0056] Specifically, vibration signals need to be preprocessed before being input into the model to ensure that the temporal characteristics of the data are effectively preserved and to eliminate the influence of different acquisition frequencies.

[0057] In this embodiment, the dataset is first divided according to a preset ratio, for example: the first 60% of the data is used as the training set, the middle 20% as the validation set, and the last 20% as the test set. Then, a starting position is randomly selected from the original vibration signal, and using this as the starting point, sliding sampling is performed within the training set, validation set, and test set with a window width of 2048 points and a step size of 28 points. Finally, through the above sliding sampling process, 3000 sets of samples for training and 1000 sets each for validation and testing are obtained.

[0058] S3: Calculate and normalize the convolutional filter of the teacher neural network according to the L2 norm, and perform structured pruning based on the percentile threshold to obtain the student neural network.

[0059] It is worth noting that in order to deploy the intelligent diagnostic model on an FPGA, a powerful yet lightweight neural network model needs to be designed. For structurally similar models, the KD-based approach can more effectively recover model performance. Therefore, a lightweight model with a similar network structure to the teacher network is constructed using a progressive structured pruning method. The study performs progressive structured pruning on the teacher neural network to remove redundant filters in each convolutional layer; whenever the pruning rate increases by 1%, the network is retrained to restore diagnostic accuracy. Through this process, a student network with fewer parameters and lower computational cost is ultimately obtained, while ensuring that the teacher and student networks have similar structures, laying the foundation for subsequent KD-based performance recovery. The progressive structured pruning process mainly includes the following technical steps:

[0060] 1. First, train the teacher network until it achieves satisfactory performance on the validation set, and initialize the mask matrix, which is used to identify which filters will be preserved and which will be pruned.

[0061] 2. For each filter corresponding to each convolutional kernel in each convolutional layer, calculate the L2 norm (the square root of the sum of squares of the filter weights); normalize the L2 norm of all filters in the layer to measure the importance of different filters.

[0062]

[0063]

[0064] in, Let the weight tensor of the j-th filter be represented. This represents the k-th weight value in the j-th filter, where k represents the weight index in the filter, K represents the number of weights in the filter, m represents the index of all filters in the current convolutional layer, and M represents the total number of filters in the current convolutional layer. Let L2 norm be the L2 norm of the m-th filter.

[0065] 3. In each layer, sort the L2 norm of each filter in ascending order, and prune the front end of the sequence according to the pruning rate R; set the value of pruned filters to 0 in the mask matrix M, indicating that the filter has been pruned and will not participate in subsequent calculations; set the value of undpruned filters to 1 in the mask matrix, indicating that the filter is retained.

[0066]

[0067]

[0068] in, The threshold for filter pruning (only filters with values ​​greater than this threshold are retained); R represents the set of L2 norms of all filters in the current layer; R represents the pruning rate, for example, R=30% means pruning the 30% of filters with the smallest norm. This represents a selection function that selects the maximum value among the clipped norms. The u-th element in the mask matrix corresponds to the j-th filter.

[0069] 4. Repeat steps 2 and 3 until the target pruning rate is reached. Each time the pruning rate increases by 1%, the network is retrained to recover the accuracy loss caused by pruning. The final target pruning rate is set at 65%. Furthermore, fully connected layers typically account for a large portion of the neural network parameters, while FPGA on-chip memory resources are limited. To reduce resource consumption, the student network is designed with only one fully connected layer. After the pruning operation, the network is reconstructed into the student network based on the number of filters remaining in each pruned layer. Information about the student network is shown in Table 1. The pruning operation significantly reduces the number of convolutional filters per layer in the student network, thereby effectively reducing the model's parameter size and computational complexity.

[0070] Table 1 Student Network Structure

[0071] Layer Kernel size number Stride Output size Padding Conv 32×1 8 8×1 512×8 Yes Maxpool 2×1 8 2×1 128×8 / Conv 3×1 16 1×1 128×16 Yes Maxpool 2×1 16 2×1 64×16 / Conv 3×1 16 1×1 64×16 Yes Maxpool 2×1 16 2×1 32×16 / Conv 3×1 16 1×1 32×16 Yes Maxpool 2×1 16 2×1 16×16 / Conv 3×1 16 1×1 16×16 Yes Maxpool 2×1 16 2×1 8×16 / FC / / / 10 /

[0072] First, the input signal passes through the first convolutional layer, which uses a 32×1 one-dimensional convolutional kernel with 8 kernels and a stride of 8. Using padding to preserve feature length, this layer outputs a size of 512×8, effectively extracting the wide-domain temporal features of the original signal. Subsequently, a max-pooling layer with a kernel size of 2×1 is used to downsample these features, with a pooling stride of 2, reducing the output size to 128×8 to compress the data size while retaining the main features.

[0073] Following this, the network sequentially stacks four sets of convolutional and pooling structures. The second to fifth convolutional layers all use 3×1 one-dimensional convolutional kernels, with 16 kernels per layer and a stride of 1, and padding is used to maintain the feature length. These convolutional layers are responsible for progressively extracting deep features from local time ranges. The corresponding four pooling layers all use 2×1 pooling windows and a stride of 2, successively reducing the feature lengths to 128, 64, 32, 16, and 8, while maintaining the number of channels at 16, thus achieving effective compression and hierarchical representation of the feature space.

[0074] Finally, the network inputs the resulting 8×16 high-dimensional features into a fully connected layer, outputting a 10-dimensional vector to perform fault diagnosis tasks for ten states. This structure has strong temporal feature extraction capabilities and is suitable for intelligent identification of vibration signals from rotating machinery.

[0075] S4: Construct a KFD strategy to train the student network, and perform asymmetric integer quantization on the parameters of the trained student network; wherein, the KFD strategy includes a feature-level distillation module and a logit-level distillation module; by weighted fusion of the loss of the feature-level distillation module and the loss of the logit-level distillation module, the training process of the student model is jointly optimized.

[0076] To recover from performance degradation caused by pruning, a KFD (Knowledge-Driven Function) method is proposed to assist in student network training. Traditional KD methods only utilize the label information of the teacher network to guide the student network in learning category knowledge, but neglect the rich feature information contained in the intermediate layers of the teacher network, failing to fully exploit the potential of the student network. To address this issue, the KFD method integrates the intermediate feature knowledge output by the teacher model and logit knowledge, and redesigns the loss function of the student network.

[0077] The fusion of these two types of knowledge enables the student network to simultaneously improve its feature extraction and fault diagnosis capabilities, greatly enhancing the model's fault diagnosis performance and noise robustness. Currently, mainstream KD methods can be broadly categorized into two types: teacher output label knowledge distillation (implemented in a logit-level distillation module, TCKD) and intermediate feature knowledge distillation (implemented in a feature-level distillation module, ICKD). In TCKD, the student network primarily learns from the soft labels generated by the teacher network, as soft labels contain richer knowledge than hard labels. Soft labels are transformed into probabilities of the i-th class by applying a softmax function to the teacher network's logits zi.

[0078]

[0079] in, is a soft label representing the probability of the i-th category; T represents the distillation temperature as a positive real number; Let represent the raw score output by the teacher network for category i without softmax processing; Q represents the number of categories; q represents the category index, q∈Q. When T is high (T>1), the probability difference between categories becomes smaller, resulting in a smoother probability distribution. When T is low (T<1), the probability difference between categories increases.

[0080] In classification tasks, cross-entropy loss (CE loss) is typically used to quantify the difference between the predicted label p and the actual label y. The CE loss function is as follows:

[0081]

[0082] This represents the true label of the i-th class, with 1 for the correct class and 0 for the rest. This represents the predicted probability of the model's output in the i-th class (obtained by softmax).

[0083] KL divergence is used to measure the similarity between the output label probabilities of the student and teacher networks; the loss represents the target knowledge.

[0084]

[0085] in, Represents the divergence loss function; This represents the probability distribution of soft labels in the teacher's network output; This represents the probability distribution of soft labels in the student's network output.

[0086] ICKD, also known as feature-based KD, utilizes intermediate feature knowledge from the teacher network's output to aid student network training. In most cases, its performance outperforms the class-information-based TCKD method. This method typically requires first aligning the feature layers of the teacher and student networks, then calculating and weighting the differences between their corresponding feature maps to guide the student network's feature learning. However, performing feature alignment and weighting layer by layer during training significantly increases training time, and the weighting coefficients for each layer's feature maps are difficult to determine, thus affecting the model's final accuracy. Therefore, a bridging connection is introduced to facilitate feature map matching between the teacher and student networks, simplifying the traditional layer-by-layer alignment approach. Considering that the student network undergoes structured pruning and typically has fewer channels than the teacher network, direct alignment is not feasible. The student network's feature map is expanded or transformed using deconvolution. Its size, after kernel transformation, is consistent with the teacher network's dimension: this bridging is achieved through a transposed convolution kernel.

[0087] Let the output feature map of the teacher network be... The output feature map of the student network is Expanded student feature map:

[0088]

[0089] Where K represents the shape as convolution kernel, and These represent the size of the convolution kernel in the height and width directions, respectively; The number of channels representing the teacher's feature map; The number of channels in the student feature map; Indicates the height of the teacher feature map; Indicates the height of the student feature map; Indicates the width of the teacher feature map; Show the width of the student feature map; This indicates the transpose convolution operation;

[0090] Typically, the features output by the last layer of a neural network contain high-level semantic information about the input data, effectively representing the complex relationship between category information and features. Therefore, to simplify the complexity of multi-layer feature map weighting in traditional methods, this paper calculates the difference between the feature maps output by the last layer of the teacher and student networks, significantly reducing the complexity of model training. The similarity between the feature map outputs of the last layer is measured using mean squared error (MSE) loss.

[0091]

[0092] Where n represents the number of samples, and b represents the sample index. This represents the teacher feature map of the b-th sample. This represents the expanded student feature map of the b-th sample. This represents the result of subtracting corresponding elements one by one.

[0093] Through Introduced in China ,make and Keep it on an order of magnitude; minimize the loss of the characteristic distillation module. And the loss of the logit-level distillation module Multiply The results are weighted and fused to obtain the fusion loss. This fusion loss is then weighted and fused with the cross-entropy loss function of the student network to obtain the complete KFD loss function.

[0094]

[0095] in and These are the weighting factors that control the CE loss and KL divergence loss, respectively.

[0096] To further reduce the model size, the parameters of each layer of the student network are quantized. Parameter quantization refers to representing 32-bit floating-point numbers with a lower bit width, which can significantly reduce memory usage. For example, quantizing 32-bit floating-point numbers into 8-bit integers can reduce memory requirements by a factor of four, thereby improving the computational efficiency of the neural network. Furthermore, FPGAs are more efficient at handling integer computations, making parameter quantization crucial for deploying neural networks on embedded platforms. An asymmetric quantization method is employed, as detailed below:

[0097]

[0098]

[0099]

[0100] in, and These represent the maximum and minimum values ​​of the parameter to be quantized, respectively. and The maximum and minimum values ​​of the quantization interval are represented by [0, 255]; S is the scaling factor, representing the mapping ratio from floating-point to integer; Z is the zero offset; and q is the parameter for the final quantization. This indicates taking the nearest integer.

[0101] S5: Deploy a general-purpose neural network operator IP core on each FPGA to deploy a quantized lightweight student model for real-time fault diagnosis.

[0102] The neural network operator IP core is: a student model that performs the asymmetric quantization.

[0103] It's worth noting that current research largely focuses on designing lightweight intelligent diagnostic models, providing numerous lightweight model design schemes. However, most of these schemes haven't been deployed on real-world edge devices, making it difficult to determine the actual performance of the models, which hasn't driven the practical application of intelligent diagnostic models. To enable intelligent diagnostic models to be used for real-time fault diagnosis of rotating machinery, this method implements a general-purpose neural network operator IP core on a ZYNQ-7020 FPGA, facilitating the deployment of intelligent diagnostic models with different architectural parameters.

[0104] For example, the hardware design and development on the FPGA side are carried out using the Vivado 2022.2 and Vivado HLS 2022.2 toolchains.

[0105] First, a general-purpose neural network computation module, including convolution, pooling, and fully connected operators, was implemented in C++ within Vivado HLS to support different model architectures on the FPGA. These three functional modules are integrated into an IP core and connected to the ZYNQ processing system via the AXIInterconnect bus for data communication. The entire data transmission architecture is designed based on the standard AXI protocol and employs a DMA mechanism to achieve efficient data transfer between the FPGA and external DDR memory. The system clock is set to 100 MHz, and the trained model parameters are quantized to 8-bit precision and preloaded into the on-chip block RAM (BRAM) to minimize loading latency and bandwidth overhead. After completing the module design, the Vivado toolchain was used to generate deployable bitstream files. To enable real-time edge inference of the intelligent diagnostic model on the FPGA, a Python-based driver was developed on the Jupyter Notebook platform. This driver facilitates high-level control and data interaction with the FPGA, thus building a hardware-software co-acceleration framework. This design not only ensures system flexibility but also significantly improves inference efficiency.

[0106] On the other hand, this embodiment also provides an intelligent diagnostic system for rotating machinery based on structured pruning and knowledge fusion distillation, which includes:

[0107] The acquisition unit collects vibration acceleration signals under typical fault conditions by conducting vibration test experiments on bearings in rotating machinery.

[0108] The training unit divides the collected vibration signals into training, validation, and test sets according to time sequence, and uses the training set to train the teacher network.

[0109] The learning unit calculates and normalizes the convolutional filters of the teacher neural network according to the L2 norm, performs structured pruning based on percentile thresholds, and obtains the student neural network. A KFD strategy is constructed to train the student network, and the parameters of the trained student network are asymmetric integer quantized. The KFD strategy includes a feature-level distillation module and a logit-level distillation module. The training process of the student model is optimized by weighted fusion of the losses from the feature-level distillation module and the logit-level distillation module.

[0110] The deployment unit arranges common neural network operator IP cores on each FPGA to deploy quantized lightweight student models for real-time fault diagnosis.

[0111] If the above functions are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this invention, or the part that contributes to the prior art, or a part 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 described in the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0112] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-including system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device.

[0113] More specific examples of computer-readable media (a non-exhaustive list) include: electrical connections (electronic devices) having one or more wires, portable computer disk drives (magnetic devices), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Furthermore, computer-readable media can even be paper or other suitable media on which the program can be printed, because the program can be obtained electronically, for example, by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in computer memory.

[0114] It should be understood that various parts of the present invention can be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented in software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, it can be implemented using any or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0115] Example 2, refer to Figure 2 As an embodiment of the present invention, a method for intelligent diagnosis of rotating machinery based on structured pruning and knowledge fusion distillation is provided. To verify the beneficial effects of the present invention, scientific demonstration is carried out through economic benefit calculation and simulation experiments.

[0116] Experiment 1: JNU_Bearing Dataset; The test bench was a fault diagnosis test of a centrifugal fan system using a Mitsubishi SB-JR induction motor. The motor was a 3.7KW three-phase induction motor with a voltage of 220V, 4 poles, and a rated speed of 1800rpm. The rotor was supported by two bearings, one of which had a defect. The sensor was mounted on the bearing housing. Notably, the defective bearing was located on the motor's output shaft. Two types of bearings, N205 and NU205, were used for testing. N205 bearings were used for normal (NC), outer ring fault (OF), and rolling fault (BF); NU205 bearings with separable outer rings were used for inner ring fault (IF). Three different speeds were set: 600rpm, 800rpm, and 1000rpm. The accelerometer sampling frequency was 50kHz, and the sampling time was 20s. Ten data types were selected based on speed and fault category, as detailed in Table 2.

[0117] Table 2. Bearing data and corresponding labels used in the experiment.

[0118] Motor speed (rpm) Fault type Label 1000 OF 0 IF 1 BF 2 800 OF 3 IF 4 BF 5 600 NC 6 OF 7 IF 8 BF 9

[0119] Experiment 2: HUST_Bearing Dataset; The experimental platform mainly consists of a motor, speed controller, and shaft, and a triaxial accelerometer is installed for bearing vibration signal acquisition. The experiment set 11 different speed conditions, using ER-16K bearings, with a sampling rate of 25.6kHz. The dataset includes vibration monitoring data for normal bearings, slightly IF bearings, slightly OF bearings, slightly BF bearings, slightly combined fault (inner ring + outer ring) (IOF) bearings, severely IF bearings, severely OF bearings, severely CF bearings, and severely IOF bearings at different speeds, totaling 9 different bearing states. The data can be used for research in signal processing, intelligent diagnosis, domain generalization, and transfer learning. In this method, 10 bearing datasets were selected based on the input shaft speed, bearing fault type, and fault severity. Details of the label correspondence with the original data labels are shown in Table 3.

[0120] Table 3 shows the selected HUST dataset samples and their corresponding labels.

[0121] Label Data Tags Label Data Tags 0 0.5X_B_20 5 C_20 1 0.5X_C_20 6 C_35 2 0.5X_O_20 7 H_20 3 0.5X_I_20 8 I_20 4 B_20 9 O_65

[0122] Dataset preprocessing:

[0123] To ensure the effectiveness of model training and the comparability of experimental results, uniform data preprocessing and parameter configuration were performed. First, the experiment strictly adhered to the principle of chronological data partitioning. Based on the chronological order of data collection, the first 60% of the original data was used as the training set, the middle 20% as the validation set, and the last 20% as the test set. Then, within each subset, the signal was resampled using a sliding window of size 2048 data points with a step size of 28. This process ensured no overlap between the training, validation, and test sets. 1000 samples were collected for each data type. A total of 20,000 samples were obtained from the two datasets and then divided into training, validation, and test sets in a 3:1:1 ratio for model parameter training, hyperparameter optimization, and final performance evaluation, respectively.

[0124] Training hyperparameter settings

[0125] The model structure and parameters used in the experiment are shown in Table 1. The model was trained using the Adam optimizer with an initial learning rate of 0.0005, a maximum number of iterations of 50, a batch size of 64, and an early stopping strategy to prevent overfitting. The parameters of the proposed model's loss function are set as follows: , , .

[0126] To fully verify the effectiveness and advancement of the proposed model in fault diagnosis tasks, a systematic comparative experiment was designed, covering multiple mainstream model algorithms to ensure the scientific rigor of the comparison results. Specifically, three representative comparative algorithms were selected: (1) the classic model based on non-graph structure - Multilayer Perceptron (MLP), which only utilizes the feature information of the nodes themselves and cannot capture topological dependencies, serving as the benchmark for convolutional neural network modeling; (2) some advanced lightweight intelligent diagnostic models, including the lightweight intelligent diagnostic network (KD-Net) implemented using KD, the fault diagnosis model (NASPCNN) implemented using neural architecture search and model pruning, the lightweight intelligent diagnostic model (BearingPga-Net) implemented based on decoupled knowledge distillation (DKD), and the intelligent diagnostic model with strong noise robustness (TICNN). These methods achieve extremely high diagnostic performance with fewer parameters.

[0127] First, the number of parameters of these lightweight models and the time consumed to infer 1000 samples on a computer equipped with a GTX 1650 were compared. The experimental structure is shown in Table 4.

[0128] Table 4 compares the properties of the proposed method with those of other lightweight models.

[0129] method Parameters Inference time (s) KD-Net 26.71K 0.0594 NASPCNN 10.48K 0.1378 BearingPGA-Net 2.83K 0.0539 TICNN 716.48K 0.1896 Proposed 4.21K 0.0516

[0130] Table 4 shows a comparison of the parameters of each model. Among the compared models, TICNN has the most parameters, while BearingPGA-Net has the fewest. The proposed method has slightly more parameters than BearingPGA-Net, but this difference is small and does not affect the deployment of the model on FPGA. In addition, BearingPGA-Net's computational cost increases due to the introduction of Fast Fourier Transform.

[0131] Table 5. Test results of benchmark algorithms and proposed methods on different datasets.

[0132] method JNU_Bearing HUST_Bearing MLP 74.24% 79.50% KD-NET 92.13% 92.69% NASPCNN 92.08% 91.34% BearingPGA-Net 96.66% 95.35% TICNN 97.59% 97.46% Proposed 98.32% 98.67%

[0133] Table 5 shows the experimental results of the baseline model and the proposed method on the two datasets. The proposed model significantly outperforms the existing methods in classification accuracy on both datasets, demonstrating good robustness and generalization ability. Specifically, the proposed model achieves the highest classification accuracy of 98.32% on the JNU_Bearing dataset, surpassing the best models TICNN and BearingPGA_Net. The experimental structure on the HUST_Bearing dataset also verifies the performance of the proposed model. This further verifies its strong adaptability and robustness on different datasets. From the overall performance of the comparison models, the traditional MLP model has a low classification accuracy on all three datasets because it does not consider the topological structure and dependencies between nodes. NASPCNN achieves model lightweighting through pruning, but the number of filters and channels in the pruned model decreases, leading to a decline in model performance. KD-Net uses KD to help train the student model, effectively improving the classification accuracy of the lightweight model, but it uses the traditional KD method, and the student model can only acquire limited knowledge, limiting its performance. BearingPGA-Net utilizes DKD to assist student model training, achieving better results compared to the traditional KD method. However, DKD lacks intermediate feature knowledge from the teacher model, relying instead on logit knowledge for student model training, which can negatively impact the student model's generalization ability. TICNN's first convolutional kernel is a wide kernel, enhancing the model's robustness to time shifts; however, its large parameter count makes it difficult to deploy on embedded platforms. Overall, experimental results demonstrate that our proposed method not only outperforms existing mainstream models in classification accuracy but also possesses stronger generalization ability and adaptability to complex environments, fully showcasing its application potential in high-end equipment health monitoring and intelligent fault diagnosis.

[0134] This method deploys a fault diagnosis model on an FPGA platform, aiming to enable its practical application. To evaluate the difference in inference accuracy between the proposed model and PyTorch platforms, comparative experiments were conducted on two datasets. Each experiment was repeated 10 times, and the average results were reported. As shown in Table 6, the F1 score, recall, and accuracy of the model deployed on the FPGA decreased by less than 0.5%. This confirms the effectiveness of the proposed method in hardware deployment. Furthermore, the study compared the power consumption of the model during inference on different platforms, and the experimental results are shown in Table 7. The model was deployed on an FPGA (ZYNQ7020) and inferred at a clock frequency of 100MHz, consuming only 1.74 W. Compared to CPU and GPU platforms, power consumption was reduced by 16 times and 32.66 times, respectively. This significant energy efficiency is mainly attributed to the optimized neural network operator IP cores on the FPGA.

[0135] Table 6 compares the experimental results of the models implemented on FPGA and PyTorch on the two datasets.

[0136] Implementation method F1 score (%) Recall rate (%) Accuracy (%) PyTorch (JNU_Bearing) 99.21 99.08 99.34 FPGA (JNU_Bearing) 98.88 98.89 98.87 PyTorch (HUST_Bearing) 98.74 98.95 98.53 FPGA (HUST_Bearing) 98.65 98.91 98.39

[0137] Table 7. Comparison of inference power consumption of the model on different platforms

[0138] hardware platform Power consumption Intel i5-9300H CPU 27.83W NVIDIA GTX 1650 56.83W ZYNQXC7Z020@100MHz 1.74W

[0139] The utilization rate of FPGA internal resources is a key indicator for evaluating the feasibility of engineering implementation. After deploying the model on the FPGA, the utilization rates of various resources are shown in Table 8. The utilization rates of lookup tables (LUTs), flip-flops (FFs), BRAM, and digital signal processors (DSPs) are 24.18%, 18.66%, 2.86%, and 26.36%, respectively. Overall resource utilization is relatively balanced, with sufficient margin in each resource segment to facilitate the integration of more modules in the future.

[0140] Table 8 FPGA Internal Resource Usage

[0141] Resource Utilization Available Utilization (%) LUT 13198 53200 24.81 LUTRAM 778 17400 4.47 FF 19857 106400 18.66 BRAM 4 140 2.86 DSP 58 220 25.36 BUFG 6 32 18.75 IO 27 125 21.60 MMCM 1 4 25.00

[0142] To more comprehensively evaluate the necessity of key modules during model training, ablation experiments were conducted. The structure of the proposed model was obtained through structured pruning of the teacher network, and the performance of the pruned model was then recovered using the KFD method. Therefore, the ablation study mainly consists of two parts: whether the pruning rate can be further improved and the necessity of the two types of knowledge in the KFD method.

[0143] This ablation study aimed to systematically evaluate the impact of increasing the teacher network pruning rate on model performance and conducted validation experiments on two datasets. Pruning rates ranged from 65% to 85% in increments of 2.5%. For each increase in pruning rate, 10 independent experiments were performed, and the mean diagnostic accuracy was reported. Figure 2 The fault diagnosis accuracy results for the JNU_Bearing and HUST_Bearing datasets are presented separately. The JNU_Bearing dataset shows that the model accuracy gradually decreases as the pruning rate increases. When the pruning rate exceeds 75%, the diagnostic accuracy drops below 90%, which fails to meet the accuracy requirements for industrial applications. Experiments on the HUST_Bearing dataset show a similar trend. Therefore, this method ultimately sets the pruning rate to 65%.

[0144] To verify the necessity and effectiveness of the two types of knowledge (feature-level knowledge and logit-level knowledge) in the proposed KFD method, this method modifies the loss function during the student network training phase, removing one type of knowledge for comparative experiments. The experiments were repeated 10 times for each setting on two datasets, and the average results are shown in Table 9. Experimental results show that when only feature-level knowledge is retained for distillation, the student model still achieves high diagnostic accuracy, significantly outperforming the case of using only logit-level knowledge. This indicates that feature-level knowledge plays a more crucial role in helping the student model learn effective representations. This is because feature-level knowledge directly originates from the intermediate layer feature maps of the teacher network, containing rich temporal and spatial representation information, providing fine-grained feature alignment guidance for the student network, thereby improving its feature extraction capabilities. Logit-level knowledge, on the other hand, provides supplementary information for category discrimination to some extent. Overall, the joint distillation of both types of knowledge further improves the performance of the student network, validating the rationality and effectiveness of the proposed KFD strategy.

[0145] Table 9. The impact of different knowledge on model performance in the KFD method.

[0146] Logit knowledge Feature knowledge JNU_Bearing HUST_Bearing × × 85.74% 88.69% × √ 95.88% 96.87% √ × 93.28% 91.36% √ √ 98.37% 98.69%

[0147] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A method for intelligent diagnosis of rotating machinery based on structured pruning and knowledge fusion distillation, characterized in that, include: By conducting vibration test experiments on typical bearing faults in rotating machinery, vibration acceleration signals under typical fault conditions are collected. The collected vibration signals were divided into training set, validation set and test set according to time sequence, and the teacher network was trained using the training set. The convolutional filter of the teacher neural network is calculated and normalized according to the L2 norm, and structured pruning is performed according to the percentile threshold to obtain the student neural network. A KFD strategy is constructed to train a student network, and the parameters of the trained student network are subjected to asymmetric integer quantization. The KFD strategy includes a feature-level distillation module and a logit-level distillation module. The training process of the student model is optimized by weighted fusion of the loss of the feature-level distillation module and the loss of the logit-level distillation module. A general-purpose neural network operator IP core is deployed on each FPGA to deploy a quantized lightweight student model for real-time fault diagnosis.

2. The intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation as described in claim 1, characterized in that: The typical fault states include healthy state, outer ring fault, inner ring fault, rolling element fault, and combined fault.

3. The intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation as described in claim 2, characterized in that: After the teacher network is trained, the filter pruning is marked using the initialized mask matrix; For each filter corresponding to each convolutional kernel in each convolutional layer, the L2 norm is calculated; the L2 norm of all filters in the layer is normalized to measure the importance of different filters. In each layer, the L2 norm of each filter is arranged in ascending order, and the front end of the sequence is pruned according to the pruning rate R. The pruned filters are assigned a value of 0 in the mask matrix M, indicating that the filter has been pruned and will not participate in subsequent calculations; the unpruned filters are assigned a value of 1 in the mask matrix, indicating that the filter is retained. Repeat the pruning process until the target pruning rate is achieved; Each time the pruning rate increases by 1%, the teacher network is retrained to recover the accuracy loss caused by pruning; After the pruning operation is completed, the network is reconstructed into a student network based on the number of filters remaining in each pruned layer.

4. The intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation as described in claim 3, characterized in that: In the logit-level distillation module, soft tags are generated based on the logits output by the teacher network, using the softmax function and combining the distillation temperature T. in, is a soft label representing the probability of the i-th category; T represents the distillation temperature as a positive real number; Let represent the raw score output by the teacher network for category i without softmax processing; Q represents the number of categories; q represents the category index, q∈Q; KL divergence is used to measure the similarity between the output label probabilities of the student and teacher networks; the loss represents the target knowledge. in, Represents the divergence loss function; This represents the probability distribution of soft labels in the teacher's network output; This represents the probability distribution of soft labels in the student's network output.

5. The intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation as described in claim 4, characterized in that: The feature-level distillation module includes simplifying the process of aligning the feature layers of the teacher network and the student network when the intermediate feature knowledge output by the teacher network helps train the student network: By introducing bridge connections, the matching of feature maps output by teachers and students in the network is facilitated, thereby simplifying the feature map matching process of layer-by-layer alignment. The bridge connection is achieved through transposed convolution kernels; let the output feature map of the teacher network be... The output feature map of the student network is ; Expanded student feature map: Where K represents the shape as convolution kernel, and These represent the size of the convolution kernel in the height and width directions, respectively; The number of channels representing the teacher's feature map; The number of channels in the student feature map; Indicates the height of the teacher feature map; Indicates the height of the student feature map; Indicates the width of the teacher feature map; Show the width of the student feature map; This indicates the transpose convolution operation; The similarity between the feature map outputs of the last layer of the model is measured using mean squared error loss. Where n represents the number of samples, and b represents the sample index. This represents the teacher feature map of the b-th sample. This represents the expanded student feature map of the b-th sample. This represents the result of subtracting corresponding elements one by one. Through Introduced in China ,make and Keep it on an order of magnitude; minimize the loss of the characteristic distillation module. And the loss of the logit-level distillation module Multiply The result, after weighted fusion, yields the fusion loss; The complete KFD loss function is obtained by weighting and fusing the fusion loss with the cross-entropy loss function of the student network.

6. The intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation as described in claim 5, characterized in that: The asymmetric quantization includes quantizing the parameters of each layer of the student network and then simplifying the number of floating points. in, and These represent the maximum and minimum values ​​of the parameter to be quantized, respectively. and The maximum and minimum values ​​of the quantization interval are represented by [0, 255]; S is the scaling factor, representing the mapping ratio from floating-point to integer; Z is the zero offset; and q is the parameter for the final quantization. This indicates taking the closest integer.

7. The intelligent diagnostic method for rotating machinery based on structured pruning and knowledge fusion distillation as described in claim 6, characterized in that: The neural network operator IP core is: a student model that performs the asymmetric quantization.

8. A rotating machinery intelligent diagnostic system based on structured pruning and knowledge fusion distillation, employing the method described in any one of claims 1-7, characterized in that: The acquisition unit collects vibration acceleration signals under typical fault conditions by conducting vibration test experiments on typical bearing faults in rotating machinery. The training unit divides the collected vibration signals into training, validation, and test sets according to time sequence, and uses the training set to train the teacher network. The learning unit calculates and normalizes the convolutional filters of the teacher neural network according to the L2 norm, performs structured pruning based on percentile thresholds, and obtains the student neural network. A KFD strategy is constructed to train the student network, and the parameters of the trained student network are asymmetric integer quantized. The KFD strategy includes a feature-level distillation module and a logit-level distillation module. The training process of the student model is optimized by weighted fusion of the losses from the feature-level distillation module and the logit-level distillation module. The deployment unit arranges common neural network operator IP cores on each FPGA to deploy quantized lightweight student models for real-time fault diagnosis.

9. A computer device, comprising: A memory and a processor; the memory stores a computer program, characterized in that: when the processor executes the computer program, it implements the steps of the method as described in any one of claims 1-7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, it implements the steps of the method as described in any one of claims 1-7.

Images