A method for diagnosing imbalance faults in complex equipment based on Feature-level SMOTE

Abstract

The application provides a Feature-level SMOTE-based complex equipment unbalanced fault diagnosis method, which maps samples to an embedded space and uses MLP to perform fault diagnosis on the samples in the embedded space. The Feature-level SMOTE-based complex equipment unbalanced fault diagnosis method provided by the application has a feature-level data enhancement mechanism, so that the generated fault samples and normal samples have a smaller degree of aliasing, which is more conducive to normal and fault diagnosis; the GRU in the model can capture complex relationships in multi-dimensional monitoring data and better represent the characteristics of original samples; the DSGRU can resist the influence of noise when performing space mapping, and effectively solves the noise problem of engine monitoring data.

Description

Technical Field

[0001] This application belongs to the technical field of fault diagnosis methods for unbalanced complex equipment, and more specifically, it relates to a fault diagnosis method for unbalanced complex equipment based on Feature-level SMOTE. Background Technology

[0002] Complex equipment operates under extremely harsh environments such as high temperature, high pressure, high speed rotation, and high-intensity vibration for extended periods. Inevitably, its components will experience performance degradation and even failure, increasing the probability of engineering accidents. Take the aero-engine, a core subsystem of an aircraft, as an example: its reliability directly impacts flight safety. Early fault diagnosis of engines is crucial for preventing major flight accidents. In other words, if engine faults can be diagnosed promptly, safe engine operation can be ensured through maintenance, while also saving on maintenance costs. Therefore, real-time fault diagnosis of engines has become one of the important measures in engine health management.

[0003] Engine fault diagnosis methods can be broadly categorized into three types: physical model-based methods, traditional machine learning-based methods, and deep learning-based methods. On one hand, physical model-based methods require establishing an accurate physical model to describe the engine's operating state. However, the damage propagation process and dynamic response of complex equipment are highly intricate, making the entire modeling process extremely challenging. On the other hand, traditional machine learning-based methods require engineers to manually select statistical features from monitoring data. If the selected features do not accurately characterize the engine's health, the method risks failure. Conversely, deep learning-based methods can automatically learn rich and useful features from monitoring data and then use these features to infer the engine's health. This eliminates the need for complex modeling processes and manual feature selection by engineers, making fault diagnosis more direct.

[0004] However, directly using traditional deep learning methods for engine fault diagnosis still faces the following challenges: (1) Class imbalance: The number of normal samples in the training set is far greater than the number of fault samples. This means that even if the deep neural network cannot correctly diagnose fault samples during training, it can still achieve very high classification accuracy. For example, if the imbalance ratio of the dataset is 99:1, then even if the deep neural network diagnoses all training samples as normal samples, the classification accuracy of the model is still as high as 99%. (2) Class aliasing, such as Figure 1As shown in (a), normal samples and faulty samples are mixed together. Furthermore, in the mixed regions, the probability density of normal samples is even higher than that of faulty samples, posing a significant challenge to the classifier's learning. Because in this situation, traditional classification models tend to diagnose faulty samples as normal samples, which is a very poor diagnostic result. Therefore, a crucial task of this application is to balance the dataset and reduce inter-class aliasing.

[0005] To date, resampling remains a crucial method for addressing imbalanced classification problems, primarily categorized into two types: downsampling and oversampling. Downsampling balances the number of samples in each class by removing samples from the majority class; however, this removal strategy easily leads to the loss of useful information. To address this information loss issue, many improved downsampling techniques selectively, rather than randomly, remove samples from the majority class, such as the Neighborhood Cleaning Rule, Tomek Link, One-Sided Selection, Clustering-based Downsampling, and NB-based Downsampling. While these techniques strive to avoid removing representative majority class samples, they still cannot completely prevent the loss of useful information.

[0006] Oversampling techniques balance the number of samples by adding minority class samples rather than removing majority class samples, effectively avoiding information loss. The simplest random oversampling technique balances the number of samples in each class by randomly copying minority class samples, but this random copying strategy is prone to overfitting the classifier. The popular SMOTE algorithm amplifies minority class samples by generating them instead of randomly copying them, which can alleviate the overfitting problem to some extent. Furthermore, to address the shortcoming of the SMOTE algorithm, which does not consider the distribution of majority class samples and may introduce noisy samples, many improved SMOTE algorithms have emerged in recent years to improve the quality of generated samples, including Borderline-SMOTE, SVM-SMOTE, and KMeans-SMOTE. However, when majority and minority class samples are mixed, the SMOTE algorithm and its variants will further increase the degree of mixing, which poses a significant challenge to the classifier's learning.

[0007] Taking the SMOTE algorithm as an example, the SMOTE algorithm generates fault samples by randomly sampling along the lines connecting adjacent minority class samples in the original space. The addition of generated samples makes it possible for the sample distribution to change as follows: Figure 1 As shown in (b), this is clearly better than Figure 1(a) shows the sample distribution. Because the probability density of faulty samples is higher than that of normal samples at the center of the aliasing region, these faults can be diagnosed.

[0008] However, directly performing data augmentation on surfaces in the original space still has limitations. On the one hand, such as... Figure 1 As shown in (b), at the center of the aliasing region, normal samples face the risk of being diagnosed as faulty samples. In other words, improving the accuracy for faulty samples comes at the expense of the accuracy for normal samples. On the other hand, at the edges of the aliasing region, the probability density of faulty samples is lower than that of normal samples, and they still tend to be incorrectly diagnosed as normal samples by traditional classification models. This application uses DSGRU to map the original data to a feature space, where normal samples and faulty samples are far apart, such as... Figure 1 As shown in (c). Then, SMOTE is used for data augmentation in the feature space to balance the number of faulty samples and normal samples, as shown. Figure 1 As shown in (d). Summary of the Invention

[0009] To achieve the above objectives, the technical solution adopted in this application is: to provide a method for diagnosing unbalanced faults in complex equipment based on Feature-level SMOTE, which maps samples to an embedded space and uses MLP to diagnose faults in the samples within the embedded space.

[0010] Optionally, a training process is included, which includes the following steps:

[0011] Step 1: Data processing to obtain fault characteristic parameters;

[0012] Step 2: Spatial mapping during training. DSGRU is used to implement spatial mapping, mapping aliased samples to the embedded space, reducing the degree of aliasing between normal and faulty samples in the embedded space.

[0013] Step 3: Data augmentation. The SMOTE algorithm is used to augment the fault samples and balance the differences in the number of samples of each type. In the embedded space of normal samples and fault samples, the SMOTE algorithm is used to generate fault samples belonging to the minority class, and together with the original normal samples, they form a balanced dataset.

[0014] Step 4: Fault classification during training. MLP is used to diagnose faults in the data-augmented samples in the embedded space, and a mapping between the embedded representation of the sample and the label is constructed to identify faults.

[0015] Optionally, in step two, DSGRU includes a feature extraction module and a loss calculation module. The spatial mapping during the training process uses a GRU network as the feature extraction module of the Siamese neural network. The GRU network includes two GRU layers and one fully connected layer. Each GRU layer includes multiple GRU units.

[0016] The computation function for a GRU cell is shown below:

[0017]

[0018]

[0019]

[0020] .

[0021] Optionally, the loss calculation module uses contrastive loss to train the weights of the Siamese neural network. The contrastive loss is defined as follows:

[0022] .

[0023] Optionally, when minimizing contrast loss At that time, if and Samples of the same type Compared with the loss of the first item It tends to get smaller and smaller. and Getting closer and closer; conversely, and Samples belonging to different types ,but It tends to become smaller and smaller, that is It will get bigger and bigger, but it won't exceed... , and They are getting further and further away.

[0024] Optionally, in step three, the generation process for any fault sample is as follows:

[0025] First, find the... The embedded representation of the closest fault sample is shown as:

[0026]

[0027] Secondly, in and A point is randomly selected on the line connecting the points, which is the generated fault sample, as shown below:

[0028] ;

[0029] Finally, repeat the above process until the number of faulty samples generated is approximately equal across all types of samples in the training set.

[0030] Optionally, after balancing the dataset in the embedded space, an MLP is used to diagnose the engine's health status; the MLP consists of an input layer, two hidden layers, and an output layer.

[0031] The MLP takes the embedded representation of the sample as input and outputs the probability that the sample belongs to each category after a series of transformations. The cross-entropy loss function is calculated based on the predicted label and the true label and used to train the weight parameters of the network, so that the trained MLP can be used to classify the engine health status.

[0032] Optionally, a testing process may also be included, which comprises the following steps:

[0033] Step 5: Test process spatial mapping, the feature extraction module maps the test samples from the original space to the embedded space;

[0034] Step Six: Fault Classification in the Testing Process. In the embedded space, the trained MLP is used to determine the type of test samples.

[0035] Optionally, engine fault characteristic parameters include exhaust temperature margin, exhaust temperature deviation, core engine speed deviation, and fuel flow deviation.

[0036] Optionally, a sliding window method is used to construct samples for the fault characteristic parameters. The sample construction process is as follows:

[0037] 1) Determine the time of engine failure and obtain data on key fault characteristic parameters between the occurrence of the failure. The key fault characteristic parameters of this engine are shown below:

[0038] ;

[0039] 2) The dimensions of the sliding window are set as follows: The sliding window's step size is set to 10, and the sliding window slides from the end to the beginning. The first engine The following are some examples of fault symptoms:

[0040] ,

[0041] when hour, Indicates a fault sample; when hour, Indicates a normal sample;

[0042] 3) The set of normal samples is denoted as The set of exhaust temperature indication fault samples is denoted as The set of samples of imported total temperature indicator failures is denoted as ;

[0043] The dataset is divided using a five-fold crosswise partitioning method, separating the original data. Divide each set into five disjoint subsets;

[0044] Each time, a subset is selected as the test set. ;

[0045] The remaining four subsets are used as the training set. ;

[0046] The training set is ;

[0047] The test set is .

[0048] This application provides a feature-level SMOTE-based method for diagnosing imbalanced faults in complex equipment. Addressing the issue of poor performance of existing supervised fault diagnosis methods on imbalanced high-dimensional monitoring data, this project introduces a feature-level data augmentation mechanism into the learned mapping space. A deep Siamese gated recurrent network (DSGRU) model is constructed to learn a mapping space that can effectively separate normal and abnormal samples. Then, SMOTE is used to augment data in the learned mapping space, and finally, a multilayer perceptron (MLP) is employed for fault diagnosis. The constructed feature-level SMOTE consists of a DSGRU, a SMOTE, and an MLP. The DSGRU is trained with sample pairs to map normal and abnormal samples into a mutually separate feature space. SMOTE, as a feature-level data augmentation mechanism, generates fault samples in the feature space, and the MLP directly classifies the embedded representations of the samples. The advantages of Feature-level SMOTE are: (1) The feature-level data augmentation mechanism makes the generated fault samples less mixed with normal samples, which is more conducive to the diagnosis of normal and fault; (2) The GRU in the model can capture the complex relationship in multidimensional monitoring data and better characterize the features of the original sample; (3) DSGRU can resist the influence of noise when performing spatial mapping, effectively solving the noise problem in engine monitoring data. Attached Figure Description

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

[0050] Figure 1 This is a schematic diagram of the proposed framework.

[0051] Figure 2 This is a schematic diagram of data preprocessing.

[0052] Figure 3 This is the main flowchart of the proposed framework.

[0053] Figure 4 The experimental results of the method under consideration are shown in the figure. Detailed Implementation

[0054] To make the technical problems, technical solutions, and beneficial effects to be solved by this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and are not intended to limit the scope of this application.

[0055] This application now describes a method for diagnosing imbalance faults in complex equipment based on Feature-level SMOTE. For example... Figure 2 , Figure 3 As shown, the complex equipment imbalance fault diagnosis method based on Feature-level SMOTE includes a training process and a testing process. The training process includes the following steps:

[0056] Step 1: Data Processing. The raw data is denoised and smoothed to obtain fault characteristic parameters.

[0057] Step 2: Spatial mapping during training. DSGRU is used to implement spatial mapping, mapping aliased samples to the embedded space, reducing the degree of aliasing between normal and faulty samples in the embedded space.

[0058] DSGRU stands for Deep Siamese Gated Recurrent Unit Network. In this paper, it is simply referred to as DSGRU. DSGRU includes a feature extraction module and a loss calculation module.

[0059] Step 3: Data Augmentation. The SMOTE algorithm is used to augment the faulty samples, balancing the numerical differences between different sample types. Within the embedded space of normal and faulty samples, the SMOTE algorithm generates faulty samples belonging to the minority class, which are then combined with the original normal samples to form a balanced dataset. Furthermore, the newly generated faulty samples in the embedded space do not significantly overlap with normal samples.

[0060] Step 4: Fault classification during training. MLP is used to diagnose faults in the data-augmented samples in the embedded space, and a mapping between the embedded representation of the sample and the label is constructed to accurately identify the fault.

[0061] MLP stands for Multilayer Perceptron, and in this paper, it will be referred to simply as MLP.

[0062] See Figure 3 The testing process includes the following steps:

[0063] Step 5: Test process spatial mapping, the feature extraction module maps the test samples from the original space to the embedded space;

[0064] Step Six: Fault Classification in the Testing Process. In the embedded space, the trained MLP is used to determine the type of test samples.

[0065] In step one, the engine's fault characteristic parameters reflect the performance status of the entire engine and its components. Extracting fault symptoms (fault features) from these parameters is a crucial step in fault diagnosis. Among the many engine fault characteristic parameters, important and effective parameters include exhaust gas temperature (EGT), low-pressure rotor speed (N1), high-pressure rotor speed (N2), and fuel flow rate (FF). However, in actual flight, the measured values ​​of these fault characteristic parameters are also affected by external environmental conditions, operating conditions, and engine thrust. Directly using the measured values ​​may lead to misjudgments of the engine's performance status.

[0066] To more accurately reflect engine performance, original equipment manufacturers (OEMs) combine engine performance baseline models, external environmental conditions, and engine thrust magnitude to convert measured values ​​into baseline deviation values. For example... Figure 2 As shown, GE converts exhaust temperature, core engine speed, and fuel flow into exhaust temperature margin (EGTM), exhaust temperature deviation (DEGT), core engine speed deviation (DN2), and fuel flow deviation (DFF) based on parameters such as flight altitude, Mach number, and thrust.

[0067] This application selects EGTM, DEGT, DN2, and DFF as key characteristic parameters for engine fault diagnosis.

[0068] The sliding window method was used to construct samples for key fault characteristic parameters. The sample construction process is as follows:

[0069] 1) Determine the time of engine failure and obtain data on key fault characteristic parameters between the occurrence of the failure. Specifically, based on the maintenance report, the time of engine failure can be determined. Then, data on key fault characteristic parameters prior to the failure are obtained from historical monitoring data. Therefore, the first... The key fault characteristic parameters of this engine are shown below:

[0070]

[0071] In the formula, Indicates the first The total number of flight cycles before the engine malfunctioned.

[0072] 2) Analysis of relevant CNR reports revealed that the sequence length of fault symptom fragments ranged from 5 to 120, with the vast majority not exceeding 10. Therefore, the sliding window size was ultimately set to... Furthermore, the sliding window's step size is set to 10. Additionally, the sliding window slides from the tail (i.e., the flight cycle in case of a malfunction) towards the bow. Therefore, the first... The first engine The following are some examples of fault symptoms:

[0073]

[0074] when hour, Indicates a fault sample; when hour, This indicates a normal sample.

[0075] 3) For ease of description, the set of normal samples is denoted as... In the formula Indicates the first A normal sample, The total number of normal samples is represented by ; the set of samples consisting of exhaust temperature indication fault samples is denoted as . In the formula Indicates the first One sample of exhaust temperature indicator malfunction. This represents the total number of exhaust temperature indicator fault samples; the set of inlet total temperature indicator fault samples is denoted as... In the formula Indicates the first One sample of an imported total temperature indicator malfunction. The total import temperature indicates the total number of faulty samples. To avoid randomness in a single experiment, a five-fold cross-validation method is proposed to divide the dataset, separating the original data... Divide each subset into five disjoint subsets, and select one subset as the test set each time. ;

[0076] The remaining four subsets are used as the training set. ;

[0077] The training set is ;

[0078] The test set is .

[0079] In step two, the training process spatial mapping uses a GRU network as the feature extraction module of the Siamese neural network. The GRU network includes two GRU layers and one fully connected layer.

[0080] The GRU layer is the core component of the GRU network, capable of adaptively extracting dependencies at different time scales. The computation function of a GRU unit is shown below:

[0081]

[0082]

[0083]

[0084]

[0085] In the formula, Indicates the first One sample in The value at time, Indicates the first Each loop unit in Activation of the moment Indicates candidate activation. Indicates update gate, This represents the resetgate, and , , , , as well as Both represent weight matrices. Furthermore, This represents the logistic sigmoid function, and This indicates that corresponding elements are multiplied.

[0086] according to As can be seen from the calculation formula, the GRU unit can extract the current... Information of time It can also be preserved in Important information captured from the input sequence before the specified time. Furthermore, it can carry this information over long distances.

[0087] The loss calculation module uses contrastive loss to train the weights of the Siamese neural network. Contrastive loss is effective for handling paired data and is defined as follows:

[0088]

[0089] In the formula, and Indicates the first One sample pair, yes Embedded representation, yes Embedded representation, This is its corresponding tag. It's worth noting that... The setting rules, if and Belonging to the same type, Set to 1; if and They belong to different types. Set to 0. Additionally, This represents the total number of sample pairs. This represents a threshold.

[0090] When minimizing the contrast loss At that time, if and Samples of the same type Compared with the loss of the first item It tends to get smaller and smaller, which means and Getting closer and closer. Conversely, and Samples belonging to different types ,but It tends to become smaller and smaller, that is Getting bigger and bigger (but not exceeding) This means and They move further and further apart. Therefore, the labels corresponding to normal samples and faulty samples are 0, and they tend to move further apart in the embedded space, thus having a lower degree of aliasing.

[0091] In step three, the SMOTE algorithm is used to augment the fault samples in the embedded space.

[0092] The generation process for any fault sample is as follows:

[0093] First, find the... The embedded representation of the closest fault sample can be expressed as:

[0094]

[0095] In the formula, For the first One fault sample The embedded representation, the corresponding tag is ,and Indicates and The most similar embedded representation of the same type.

[0096] Secondly, in and Randomly select a point on the line connecting the points to generate a fault sample, as shown below:

[0097]

[0098] In the formula, This represents the embedded representation of the generated samples. Furthermore, Let represent a random variable that follows a uniform distribution in the range [0,1]. Furthermore, and belonging to the same type and Only samples of the same type in the embedded space are close to each other. It is very likely an embedded representation of a fault sample.

[0099] Finally, repeat the above process until the number of faulty samples generated is approximately equal among the samples of each type in the training set.

[0100] In step four, fault diagnosis is performed on the data-augmented samples in the embedded space. After balancing the dataset in the embedded space, MLP is used to diagnose the engine's health status.

[0101] An MLP consists of an input layer, two hidden layers, and an output layer.

[0102] The MLP takes the embedded representation of a sample as input and outputs the probability that the sample belongs to each category after a series of transformations. Then, the cross-entropy loss function is calculated based on the predicted label and the true label, and used to train the weight parameters of the network, so that the trained MLP can be used for classifying engine health status.

[0103] In step five, the space mapping for the testing process is the same as that for the training process.

[0104] In step six, the fault classification during the testing process is the same as that during the training process.

[0105] In this application, engine monitoring data was collected to evaluate the effectiveness of the proposed fault diagnosis model. The data came from real operational data of an Asian airline, not simulated data. Based on maintenance reports, a total of 1047 samples were collected under three conditions, including 984 normal samples, 38 exhaust temperature indication fault samples, and 25 inlet total temperature indication fault samples. The dataset was then split using a five-fold cross-validation method. Unless otherwise specified, the number of samples in the training set is based on the first fold, as shown in Table 1.

[0106] Table 1: Engine Samples

[0107]

[0108] To train the DSGRU model, the samples in the training set need to be paired. First, pairs of samples belonging to the same type are constructed, with the corresponding label set to 1: (1) Each normal sample is paired with its 5 nearest normal samples. (2) Each sample with an exhaust temperature indicator fault is paired with all samples with exhaust temperature indicator faults. On the one hand, the number of exhaust temperature indicator fault samples is relatively small; on the other hand, the embedded representations of all exhaust temperature indicator fault samples are made as close as possible to each other. (3) Each sample with an inlet total temperature indicator fault is also paired with all samples with inlet total temperature indicator faults.

[0109] Then, sample pairs belonging to different types were constructed, with the corresponding labels set to 0: (1) To ensure that the number of sample pairs of the same type and sample pairs of different types is approximately the same, each sample of exhaust temperature indication failure was paired with its 85 nearest normal samples. (2) Each sample of inlet total temperature indication failure was also paired with its 85 nearest normal samples. (3) Each sample of exhaust temperature indication failure was paired with all samples of inlet total temperature indication failure. On the one hand, the number of samples for the two types of failures was relatively small; on the other hand, the embedded representations of the samples for the two types of failures were kept as far apart as possible. See Table 2 for details.

[0110] Table 2: Paired Samples

[0111]

[0112] Experimental environment: Python 3.7 and PyTorch 1.8.0, processor: Intel i7-9750H, memory: 8GDDR4.

[0113] Trainer: The neural network was trained using Adam with a learning rate of 0.0002 and momentum... , The batch size was set to 128, and preliminary experiments determined that the maximum epoch for the Feature-level SMOTE model was 20.

[0114] Hyperparameter settings: A grid search method is used to determine the hyperparameters of the DSGRU model. The DSGRU model consists of two GRU layers and one fully connected layer with an output dimension of 64, and each GRU layer consists of 64 recurrent units. SMOTE is a nonparametric model and does not require hyperparameter settings. Additionally, the MLP model consists of one input layer, two hidden layers, and one output layer. The number of nodes in the input layer is consistent with the dimension of the embedded representation, set to 64; the number of nodes in the output layer is consistent with the sample type, set to 3; and the number of nodes in the two hidden layers is set to 2 / 3 of the number of nodes in the input layer.

[0115] In the application, the number of normal samples far exceeded the number of faulty samples, as detailed in Table 1. In the test set, there were 197 normal samples, while the combined number of faulty exhaust temperature indicator samples and faulty inlet total temperature indicator samples was only 13. Even if all test samples were diagnosed as normal, the overall accuracy is shown in Table 3.

[0116] Table 3: Confusion Matrix

[0117]

[0118] In addition, the individual diagnostic effects of normal samples, exhaust temperature indicator fault samples, and inlet total temperature indicator fault samples can be evaluated using the recall rates of each type, denoted as RON, ROE, and ROT, respectively, while the overall diagnostic effect of the model can be evaluated using Balanced Accuracy.

[0119]

[0120]

[0121]

[0122]

[0123] To verify the effectiveness of the proposed model, this application constructed four sets of comparative experiments:

[0124] In the first set of comparative experiments, in order to verify the necessity of balanced datasets, an imbalanced training set was directly used to train the GRU model.

[0125] In the second set of comparative experiments, to verify that the proposed model is more effective than some classic undersampling methods, undersampling techniques were used to reduce the number of majority class samples, and then a balanced dataset was used to train the GRU model. The undersampling techniques used in the application are Random Undersampling and Cluster-Based Undersampling, denoted as RU-GRU and CBU-GRU, respectively, and after undersampling, the number of samples in each of the three classes in the training set is 20.

[0126] In the third set of comparative experiments, to verify that the proposed model is more effective than some classic oversampling methods, data augmentation methods were first used in the original data space to balance the number of samples of each type in the training set. Then, the GRU model was trained using the balanced training set. The data augmentation methods used in the application include Random Oversampling, ADASYN, and SMOTE, denoted as RO-GRU, ADASYN-GRU, and SMOTE-GRU, respectively. After data augmentation, the number of samples of each of the three types in the training set was 787.

[0127] In the fourth set of comparative experiments, to verify that the proposed model is more effective than some state-of-the-art oversampling methods, three popular SMOTE improvement algorithms were selected for comparison: Borderline-SMOTE, SVM-SMOTE, and KMeans-SMOTE. All three improvement algorithms perform data augmentation in the original data space, and the classifier in the three comparative experiments remains a GRU network, denoted as BSMOTE-GRU, SSMOTE-GRU, and KSMOTE-GRU, respectively.

[0128] The training and test sets were partitioned using a five-fold cross-validation method, and the RON, ROE, ROT, and Balanced Accuracy results from the five experiments are presented below. Figure 4 According to Figure 4It can be seen that the Feature-level SMOTE model achieved the best Balanced Accuracy, indicating that its overall diagnostic performance is the best. For EGT fault samples, the Feature-level SMOTE model outperformed GRU, RU-GRU, RO-GRU, BSMOTE-GRU, and SSMOTE-GRU, and was comparable to ADASYN-GRU, SMOTE-GRU, and SMOTE-GRU. For TAT fault samples, the Feature-level SMOTE model outperformed all other models, with an accuracy improvement exceeding 8%. For normal samples, the Feature-level SMOTE model outperformed RU-GRU and CBU-GRU, and was comparable to ADASYN-GRU and SMOTE-GRU. However, the Feature-level SMOTE model performed worse than the GRU model on normal samples. This is because the GRU model focuses more on normal samples during training, leading to many fault samples being incorrectly diagnosed as normal samples. It is worth noting that engine safety is extremely important. In other words, in order to reduce the number of misclassified faulty samples, we can accept some misclassified normal samples, but the reverse is not true.

[0129] Table 4 shows the Balanced Accuracy of each fault diagnosis model in the five-fold cross-validation experiment, from which the following conclusions can be drawn.

[0130] (1) Compared with GRU, RU-GRU, CBU-GRU, RO-GRU, and SMOTE-GRU showed significant improvements in diagnostic performance, with Average Balanced Accuracy increasing by 1.49%, 4.70%, 4.79%, and 5.25%, respectively. This illustrates the importance of balanced datasets; balancing the difference in the number of normal and faulty samples can alleviate the problem of the model overemphasizing normal samples. Both undersampling and data augmentation techniques can bring positive benefits.

[0131] (2) Compared with RO-GRU and ADASYN-GRU, SMOTE-GRU shows an improvement in Average Balanced Accuracy. This indicates that the oversampling technology based on SMOTE is more suitable for engine monitoring data.

[0132] (3) Compared with GRU, RU-GRU, CBU-GRU, RO-GRU, ADASYN-GRU and SMOTE-GRU, the proposed model achieved the best diagnostic performance. The main reasons are as follows: on the one hand, DSGRU maps the original data to the feature space, where samples of the same type are close to each other in the embedded space, while samples of different types are far apart, which reduces the degree of overlap between different types of samples; on the other hand, data augmentation in the embedded space can balance the numerical differences between different types of samples.

[0133] (4) Compared with the three improved SMOTE algorithms, the proposed model still achieves the best diagnostic results on Average Balanced Accuracy. More specifically, the Feature-level SMOTE model improves upon BSMOTE-GRU (87.85%), SSMOTE-GRU (87.68%), and KSMOTE-GRU (88.51%) by 90.51%. This further demonstrates that the proposed model is effective on real engine datasets.

[0134] Table 4: Balanced Accuracy and Inference Time of Different Fault Diagnosis Methods

[0135]

[0136] Table 4 also shows the inference time of each fault diagnosis model on the test set. CBU-GRU has the fastest inference time, requiring 0.02 milliseconds to infer one sample. In contrast, the proposed model requires 0.09 milliseconds, a difference of 0.07 milliseconds.

[0137] Table 5 summarizes the balanced accuracy under different dimensions, demonstrating the impact of the dimension of the embedded representation on the performance of the Feature-level SMOTE model.

[0138] The Feature-level SMOTE model achieved optimal performance when the dimension of the embedded representation was 64. Too low a dimension in the embedded representation severely impacts the model's diagnostic performance because too much important information is lost during the mapping process. Of course, the dimension also cannot be too high, otherwise it will increase the difficulty of training the model. Therefore, in this experiment, the dimension of the embedded representation was chosen to be 64.

[0139] Table 5: The impact of different dimensions of embedded representation on the proposed method

[0140]

[0141] To address the multi-fault classification problem under imbalanced conditions, firstly, a mapping is learned using DSGRU to map input samples into an embedded space where samples of the same type are close together, while samples of different types are far apart. This mapping reduces the aliasing between normal and faulty samples and improves the separability between different types of samples. Then, the SMOTE algorithm is used in the embedded space to generate minority class fault samples, ensuring that the number of samples of different types in the dataset is approximately equal. Finally, an MLP is trained to classify the engine's health status.

[0142] The effectiveness of the proposed model was verified using real monitoring data from the engines of an Asian airline. Compared with GRU, CBU-GRU, RO-GRU, ADASYN-GRU, and SMOTE-GRU, the Feature-level SMOTE model showed a significant improvement in Average Balanced Accuracy. Furthermore, compared with three popular improved algorithms for SMOTE—BSMOTE-GRU, SSMOTE-GRU, and KSMOTE-GRU—the Feature-level SMOTE model still achieved the best diagnostic performance. This is attributed to two main factors: first, the DSGRU within the framework can reduce the aliasing between different types of samples through spatial mapping; and second, data augmentation in the feature space is a superior data augmentation strategy.

[0143] This application provides a feature-level SMOTE-based method for diagnosing imbalanced faults in complex equipment. Addressing the issue of poor performance of existing supervised fault diagnosis methods on imbalanced high-dimensional monitoring data, this project introduces a feature-level data augmentation mechanism into the learned mapping space. A deep Siamese gated recurrent network (DSGRU) model is constructed to learn a mapping space that can effectively separate normal and abnormal samples. Then, SMOTE is used to augment data in the learned mapping space, and finally, a multilayer perceptron (MLP) is employed for fault diagnosis. The constructed feature-level SMOTE consists of a DSGRU, a SMOTE, and an MLP. The DSGRU is trained with sample pairs to map normal and abnormal samples into a mutually separate feature space. SMOTE, as a feature-level data augmentation mechanism, generates fault samples in the feature space, and the MLP directly classifies the embedded representations of the samples. The advantages of Feature-level SMOTE are: (1) The feature-level data augmentation mechanism makes the generated fault samples less mixed with normal samples, which is more conducive to the diagnosis of normal and fault; (2) The GRU in the model can capture the complex relationship in multidimensional monitoring data and better characterize the features of the original sample; (3) DSGRU can resist the influence of noise when performing spatial mapping, effectively solving the noise problem in engine monitoring data.

[0144] The above description is merely a preferred embodiment of this application and is not intended to limit this application. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this application should be included within the protection scope of this application.

Claims

1. A method for diagnosing imbalance faults in complex equipment based on Feature-level SMOTE, characterized in that: By mapping samples to an embedded space, and then using MLP within the embedded space to diagnose faults in the samples; The training process includes the following steps: Step 1: Data processing to obtain fault characteristic parameters; Step 2: Spatial mapping during training. DSGRU is used to implement spatial mapping, mapping aliased samples to the embedded space, reducing the degree of aliasing between normal and faulty samples in the embedded space. Step 3: Data augmentation. The SMOTE algorithm is used to augment the fault samples and balance the differences in the number of samples of each type. In the embedded space of normal samples and fault samples, the SMOTE algorithm is used to generate fault samples belonging to the minority class, and together with the original normal samples, they form a balanced dataset. Step 4: Fault classification during training. MLP is used to diagnose faults in the data-augmented samples in the embedded space, constructing a mapping between the embedded representation of the sample and the label to identify the fault.

2. The method for diagnosing complex equipment imbalance faults based on Feature-level SMOTE as described in claim 1, characterized in that: In step two, DSGRU includes a feature extraction module and a loss calculation module. The spatial mapping in the training process uses a GRU network as the feature extraction module of the Siamese neural network. The GRU network includes two GRU layers and one fully connected layer. Each GRU layer includes multiple GRU units. The computation function for a GRU cell is shown below: ； In the formula, Indicates the first One sample in The value at time, Indicates the first Each loop unit in Activation of the moment Indicates candidate activation. Indicates update gate, This indicates the reset gate, where... , , , , as well as Both represent weight matrices. This represents the logistic sigmoid function. This indicates that corresponding elements are multiplied.

3. The method for diagnosing complex equipment imbalance faults based on Feature-level SMOTE as described in claim 2, characterized in that: The loss calculation module uses contrastive loss to train the weights of the Siamese neural network. The contrastive loss is defined as follows: ； In the formula, and Indicates the first One sample pair, yes Embedded representation, yes Embedded representation, It is its corresponding tag; The setting rule is that if and Belonging to the same type, Set to 1, if and They belong to different types. Set to 0; This represents the total number of sample pairs. This represents a threshold.

4. The method for diagnosing complex equipment imbalance faults based on Feature-level SMOTE as described in claim 3, characterized in that: When minimizing the contrast loss At that time, if and Samples of the same type Compared with the loss of the first item It tends to get smaller and smaller. and Getting closer and closer; conversely, and Samples belonging to different types ,but It tends to become smaller and smaller, that is It will get bigger and bigger, but it won't exceed... , and They are getting further and further away.

5. The method for diagnosing complex equipment imbalance faults based on Feature-level SMOTE as described in claim 1, characterized in that: In step three, the generation process for any fault sample is as follows: First, find the... The embedded representation of the closest fault sample is shown as: Secondly, in and A point is randomly selected on the line connecting the points, which is the generated fault sample, as shown below: ； Finally, repeat the above process until the number of fault samples generated is approximately equal among the samples of each type in the training set. In the formula, For the first One fault sample The embedded representation, the corresponding tag is , Indicates and The most similar embedded representation of the same type, For the first One fault sample The embedded representation, the corresponding tag is , The embedded representation of the generated samples. It represents a random variable.

6. The method for diagnosing complex equipment imbalance faults based on Feature-level SMOTE as described in claim 1, characterized in that: After balancing the dataset in the embedded space, an MLP is used to diagnose the engine's health status; the MLP consists of an input layer, two hidden layers, and an output layer. The MLP takes the embedded representation of the sample as input and outputs the probability that the sample belongs to each category after a series of transformations. The cross-entropy loss function is calculated based on the predicted label and the true label and used to train the weight parameters of the network, so that the trained MLP can be used to classify the engine health status.

7. The method for diagnosing complex equipment imbalance faults based on Feature-level SMOTE as described in claim 1, characterized in that: It also includes a testing process, which comprises the following steps: Step 5: Test process spatial mapping, the feature extraction module maps the test samples from the original space to the embedded space; Step Six: Fault Classification in the Testing Process. In the embedded space, the trained MLP is used to determine the type of test samples.

8. The method for diagnosing complex equipment imbalance faults based on Feature-level SMOTE as described in claim 1, characterized in that: Engine fault characteristic parameters include exhaust temperature margin, exhaust temperature deviation, core engine speed deviation, and fuel flow deviation.

9. The method for diagnosing complex equipment imbalance faults based on Feature-level SMOTE as described in claim 8, characterized in that: The sliding window method is used to construct samples for fault characteristic parameters. The sample construction process is as follows: 1) Determine the time of engine failure and obtain data on key fault characteristic parameters between the occurrence of the failure; The key fault characteristic parameters of this engine are shown below: ； In the formula, Indicates the first The total number of flight cycles prior to the engine failure; 2) The dimensions of the sliding window are set as follows: The sliding window's step size is set to 10, and the sliding window slides from the end to the beginning. The first engine The following are some examples of fault symptoms: ， when hour, Indicates a fault sample; when hour, Indicates a normal sample; 3) The set of normal samples is denoted as The set of exhaust temperature indication fault samples is denoted as The set of samples of imported total temperature indicator failures is denoted as ; The dataset is divided using a five-fold crosswise partitioning method, separating the original data. Divide each set into five disjoint subsets; Each time, a subset is selected as the test set. ; The remaining four subsets are used as the training set. ; The training set is ; The test set is .

Images