A device fault diagnosis method based on federated self-supervised learning

Abstract

This invention discloses a device fault diagnosis method based on federated self-supervised learning. The method includes: first, the server initializes the weights of the feature extractor and distributes them to each client; then, each client uses sensors to collect signals generated during local device operation and records them as local vibration data, thereby obtaining unlabeled and labeled datasets; next, each client trains its local feature extractor under a federated self-supervised learning framework, thus obtaining a trained local feature extractor; then, each client trains a classifier under a supervised learning framework, obtaining a corresponding client classifier, and connecting the feature extractor and the client classifier to form a fault diagnosis model; finally, the client's fault diagnosis model is used for device diagnosis. This invention solves the problem that rotating equipment fault datasets are small, scattered, and lack labels, making it difficult to train a high-precision diagnostic model.

Description

Technical Field

[0001] This invention belongs to the field of rotating equipment fault diagnosis, and involves a fault diagnosis method for equipment based on machine learning, deep learning and time series classification. Specifically, it involves a fault diagnosis method for equipment based on federated self-supervised learning. Background Technology

[0002] Rotating equipment is widely used in modern industry and is becoming increasingly complex and precise, such as aircraft engines and gas turbines. When rotating equipment experiences malfunctions such as bearing failure or blade breakage, it can lead to serious accidents and significant economic losses. Therefore, correctly identifying the operating status of equipment and intervening promptly when early signs of failure appear are crucial for improving production efficiency and reducing catastrophic losses.

[0003] Current fault diagnosis methods for rotating equipment largely rely on data-driven approaches, extracting the mapping relationship between vibration signals and equipment status from large amounts of data. Commonly used methods include support vector machines, decision trees, and neural networks. Deep neural networks, due to their ability to automatically extract features, are currently one of the mainstream research directions. For example, the method disclosed in the patent "A Fault Diagnosis Method for Cement Production Rotating Equipment Based on Machine Learning" uses one-dimensional convolutional neural networks and fully connected neural networks to extract vibration features, and then uses ensemble learning to obtain diagnostic results from multiple classifiers. The method disclosed in the patent "A Fault Diagnosis Method, System, and Readable Storage Medium for Rotating Equipment Based on Deep Residual Networks" uses deep residual networks to extract fault features from vibration signals.

[0004] While existing methods have achieved a high level of diagnostic accuracy, they rely on large, fully labeled datasets for training, which presents limitations in many situations. Lack of data labeling is the most common constraint. Vibration signals require annotation by domain experts, which is costly, and in practice, only a small portion of the data is labeled. Data security is also a concern. Different customers use the equipment under different operating conditions. To ensure model robustness, data from all customers should be collected as much as possible. However, customers may be unwilling to share their data for training better models due to profit considerations or concerns about data leakage risks. Summary of the Invention

[0005] To address the problems and needs existing in the background technology, this invention proposes a device fault diagnosis method based on federated self-supervised learning. This method can train a fault diagnosis model using multiple small, unlabeled datasets that are scattered and cannot be shared, and then use it for online diagnosis. It utilizes self-supervised learning to learn effective fault feature representations from a large amount of unlabeled data, and employs federated learning to train a fault diagnosis model with global knowledge from multiple clients without requiring clients to upload local data. This method can train an efficient fault diagnosis model even in scenarios where fault datasets are small, scattered, and lack labels.

[0006] The specific technical solution of this invention includes the following steps:

[0007] S1: The server initializes the weights of the feature extractor and distributes these weights to each client. Each client uses these weights as the initial weights of its local feature extractor.

[0008] S2: Each client uses sensors to collect signals generated when the local device is working and records them as local vibration data. Then, after preprocessing the local vibration data, unlabeled datasets and labeled datasets are obtained.

[0009] S3: Under the federated self-supervised learning framework, each client uses an unlabeled dataset to train a local feature extractor, thereby obtaining a trained local feature extractor.

[0010] S4: Each client trains a classifier using the labeled dataset under the supervised learning framework to obtain the corresponding client classifier. In each client, the fault diagnosis model is formed by connecting the current feature extractor with the client classifier.

[0011] S5: After preprocessing, the sensor data of the device to be diagnosed is input into the fault diagnosis model of the corresponding client to obtain the corresponding device diagnosis results.

[0012] In S1, the feature extractor employs a convolutional neural network with residual connections.

[0013] In S2, each client performs the following steps:

[0014] S21: Use an accelerometer to collect signals generated by the local device during operation and record them as local vibration data;

[0015] S22: Randomly select a preset proportion of local vibration data and label the selected local vibration data according to the actual state of the equipment to obtain an initial labeled dataset. The unselected local vibration data is recorded as the initial unlabeled dataset.

[0016] S23: Use a sliding window to divide all signals of the initial labeled dataset and unlabeled dataset into multiple segments respectively, and obtain the segmented labeled dataset and unlabeled dataset respectively;

[0017] S24: Use the max-min method to numerically scale the split labeled and unlabeled datasets respectively to obtain the final unlabeled and labeled datasets.

[0018] Specifically, S3 is:

[0019] S31: In each round of training, each client trains its local feature extractor using the unlabeled dataset under the self-supervised learning framework, obtains the weights of each client's local feature extractor after the current round of training, and uploads them to the server.

[0020] S32: After the server aggregates the local feature extractor weights of all clients, it obtains the global feature extractor weight and distributes the weight to the local feature extractors of each client.

[0021] S33: Repeat S31-S32 to update the global feature extractor weights in multiple rounds until the preset number of rounds is reached. Then, distribute the final global feature extractor weights to the local feature extractors of each client, so that each client can obtain the trained local feature extractor.

[0022] In step S31, each client performs the following steps:

[0023] S311: Use two different data augmentation methods to augment each unlabeled data in the unlabeled dataset to obtain the corresponding augmented sample pairs;

[0024] S312: Under the self-supervised learning framework, use the augmented samples corresponding to the unlabeled dataset to train the local feature extractor for one round, obtain the weights of the local feature extractor after the current round of training, and upload them to the server.

[0025] In S311, the first data augmentation sample The first step was to add Gaussian noise to each unlabeled data point, and then scale the data after adding the noise; the second data augmentation sample was obtained. It was obtained by first smoothly distorting the time step interval of each unlabeled data point, and then adding noise.

[0026] During training, the local feature extractor outputs a first feature matrix. and the first characteristic matrix The gradient descent algorithm is used to optimize the feature extractor weights. The loss function includes a first loss function and a second loss function. The formula for calculating the first loss function, loss1, is as follows:

[0027]

[0028]

[0029]

[0030]

[0031] Where N is the batch size, and α and β are the first and second hyperparameters, respectively. The indicator function; i and j represent the first and second indices of the sample in the batch, respectively; l c For the context contrast loss function, l t Time-contrast loss function This represents the first cropping feature matrix. Let represent the second clipping feature matrix, s1 and s2 represent the first and second start positions respectively, and e1 and e2 represent the first and second end positions respectively; T represents the length of the time dimension of the feature matrix; Represents the second clipping feature matrix Features of sample i at time step t′ Represents the first clipping feature matrix Features of sample i at time step t Represents the first clipping feature matrix Sample i in Represents the second clipping feature matrix Sample i in Represents the second clipping feature matrix Sample j in;

[0032] The formula for calculating the second loss function, loss2, is as follows:

[0033]

[0034] in, These represent the first feature matrices extracted by the local feature extractor of the k-th client in the r-th round. and the first characteristic matrix These represent the first feature matrices extracted by the local feature extractor of the k-th client in the p-th round. and the first characteristic matrix This indicates that each client uses the features extracted by the global feature extractor weights received from the server during the r-th round of training.

[0035] In step S32, the server uses a weighted average method to aggregate the local feature extractor weights of all clients, calculated as follows:

[0036]

[0037] Where k is the client index, |D|, |D k | represents the total data volume of the global client and the data volume of the k-th client, respectively, θ G θ k These represent the weights of the global feature extractor and the local feature extractor of the k-th client, respectively.

[0038] In S4, each client performs the following steps:

[0039] S51: Input the label dataset into the local feature extractor with updated weights to obtain the feature matrix dataset;

[0040] S52: Use the feature matrix dataset as input to the support vector machine and train the support vector machine to obtain the client classifier.

[0041] In step S5, a sliding window is used to segment the sensor data of the device to be diagnosed and normalize it using the max-min method before inputting it into the fault diagnosis model of the corresponding client.

[0042] In the method described in this invention, federated learning is used to train a feature extractor that is effective for all clients from scattered client data; during the training process, self-supervised learning is used to learn useful knowledge from a large amount of unlabeled data; and supervised learning is used to improve the final performance of the classifier from a small amount of labeled data.

[0043] Compared with existing technologies, the advantages of this invention are as follows:

[0044] 1. Model training is entirely conducted locally on the client side. Client data does not need to be uploaded to the server, so clients do not need to worry about data leakage.

[0045] 2. The method of the present invention can learn knowledge from a large amount of unlabeled data, and can perform well in the current situation where equipment fault diagnosis applications generally lack labels.

[0046] 3. This invention employs comparative self-supervised learning to train a robust model from a small, unlabeled dataset; it uses federated learning to aggregate fault feature extractors with global knowledge from multiple clients, and avoids local data sharing among clients, thereby solving the problem that rotating equipment fault datasets are small, scattered, and lack labels, making it difficult to train a high-precision diagnostic model. Attached Figure Description

[0047] Figure 1 This is a flowchart illustrating the specific steps of the present invention.

[0048] Figure 2This is a schematic diagram illustrating the training and use of the model in this invention.

[0049] Figure 3 This is a schematic diagram of the experimental platform in an embodiment of the present invention.

[0050] Figure 4 This shows the data distribution of the three clients in this embodiment of the invention.

[0051] Figure 5 This is the confusion matrix of the first client fault diagnosis result in this embodiment of the invention.

[0052] Figure 6 This is the confusion matrix of the second client fault diagnosis result in this embodiment of the invention.

[0053] Figure 7 This is the confusion matrix of the third client fault diagnosis result in this embodiment of the invention. Detailed Implementation

[0054] The present invention will be further illustrated below using the Case Western Reserve University Bearing Failure Dataset (CWRU) as a specific example.

[0055] The test bench for the CWRU dataset consists of a motor, a torque sensor, and a power meter. The motor shaft is supported by the bearing under test, and an accelerometer is mounted on the motor to sample vibration signals at a frequency of 12 kHz for one second. A schematic diagram of the test bench for this dataset is shown below. Figure 3 As shown, the bearing exhibits three types of faults: inner ring damage, outer ring damage, and roller damage. Each fault type can be further subdivided into three severity levels. Therefore, including the normal state, the bearing data presents a total of ten states.

[0056] Figure 1 and Figure 2 The process of this invention is demonstrated, and its implementation using the CWRU dataset specifically includes the following steps:

[0057] S1: The server initializes the weights of the feature extractor and distributes these weights to each client. Each client uses these weights as the initial weights of its local feature extractor.

[0058] In S1, the feature extractor uses a convolutional neural network with residual connections (ResNet), a widely used deep learning model. The feature extractor architecture is consistent between the server and the client. To accommodate time-series data, the ResNet convolutional kernels are restricted to sliding only along the time dimension.

[0059] S2: Each client uses sensors to collect signals generated when the local device is working and records them as local vibration data. Then, after preprocessing the local vibration data, unlabeled datasets and labeled datasets are obtained.

[0060] In S2, each client performs the following steps:

[0061] S21: Use an accelerometer to collect signals generated during the operation of local equipment and record them as local vibration data; specifically, such as... Figure 3 As shown, an accelerometer is installed near the bearing of the motor. The motor is run, and at a later time, the accelerometer is activated to sample the signal for ten seconds and record the bearing status.

[0062] S22: Randomly select a preset proportion of local vibration data and label the selected local vibration data according to the actual state of the equipment reflected by the data. Divide the selected local vibration data into an initial labeled dataset and an initial test set at a ratio of 1:2. The unselected local vibration data is recorded as the initial unlabeled dataset. In specific implementation, the preset proportion is set to 30%.

[0063] S23: Using a sliding window with a length of 1024 and a sliding step size of 1024, all signals from the initial labeled dataset, the initial unlabeled dataset, and the initial test set are segmented into non-overlapping segments, respectively, to obtain the segmented labeled dataset, unlabeled dataset, and test set. The CWRU dataset contains vibration data from 161 bearings. This embodiment uses three clients as an example for illustration. Therefore, after segmenting the 161 bearing vibration data, they are divided into local datasets for these three clients according to a non-independent identically distributed method. The data distribution is as follows: Figure 4 As shown, the data distribution among the three clients differs significantly. The ratio of the local labeled dataset, unlabeled dataset, and test set data volume for each client is approximately 1:7:2.

[0064] S24: Use the max-min method to numerically scale the split labeled dataset, unlabeled dataset, and test set to the [0,1] range to obtain the final unlabeled dataset, labeled dataset, and test set;

[0065] S3: Under the federated self-supervised learning framework, each client uses an unlabeled dataset to train a local feature extractor, thereby obtaining a trained local feature extractor.

[0066] S3 specifically refers to:

[0067] S31: In each round of training, each client trains its local feature extractor using the unlabeled dataset under the self-supervised learning framework, obtains the weights of each client's local feature extractor after the current round of training, and uploads them to the server.

[0068] In S31, each client performs the following steps:

[0069] S311: Use two different data augmentation methods to augment each unlabeled data in the unlabeled dataset to obtain the corresponding augmented sample pairs;

[0070] In S311, the first data augmentation sample The first step was to add Gaussian noise to each unlabeled data point, and then scale the data after adding the noise; the second data augmentation sample was obtained. This is achieved by first smoothly distorting the time step intervals of each unlabeled data point, and then adding noise. A batch of unlabeled datasets can be represented as: x train ={x 1 x 2 , ..., x N}, where x∈R L N is the batch size. In this embodiment, the data in a batch uses the same noise and scaling factor and is sampled from a standard Gaussian distribution.

[0071] S312: Under the self-supervised learning framework, the local feature extractor is trained on the dataset using augmented samples corresponding to the unlabeled dataset in one round. The weights of the local feature extractor after the current round of training are obtained and uploaded to the server. In this embodiment, ResNet is used to extract the feature representation of the augmented samples. The kernel size of ResNet is fixed at [3,1] and is restricted to sliding only along the time dimension. The output dimension of ResNet, i.e., the length of the feature representation, is set to 64.

[0072] During training, the local feature extractor f outputs the first feature matrix. and the first characteristic matrix T represents the length of the time dimension of the first feature matrix, i.e., the number of time steps. The feature extractor weights are optimized using the gradient descent algorithm. In this embodiment, the Adam optimizer is used to execute the gradient descent algorithm, with a learning rate set to 3e. -4 The loss function includes a first loss function and a second loss function. The formula for calculating the first loss function, loss1, is as follows:

[0073]

[0074]

[0075]

[0076]

[0077] Where N is the batch size, and α and β are the first and second hyperparameters, respectively, used to adjust l. c With l t The contribution weight. This is an indicator function; its value is 1 when the condition in parentheses is true, and 0 otherwise; i and j represent the first and second indices of the sample in the batch, respectively; l c The context contrast loss function aims to reduce the feature distance between augmented sample pairs output by the feature extractor, while increasing the feature distance between augmented samples and all other samples; t The temporal contrastive loss function further constrains the feature extractor's output based on the similarity of time steps. Specifically, it aims to minimize the feature distance between augmented sample pairs at the same time step, and maximize the feature distance between augmented sample pairs at different time steps and the feature distance between different time steps of each sample itself. c With l t This is a contrastive loss term designed based on the NT-Xent loss function idea. It uses the contextual and temporal dependencies between enhanced samples in the batch data to construct supervisory information, thereby helping the feature extractor benefit from unlabeled data. For the first feature matrix... Second characteristic matrix Apply random cropping to cut the data into shorter segments. The first cropping feature matrix is ​​defined as the first feature matrix from the first starting position s1 to the first ending position e1. The matrix after clipping. The second cropping feature matrix is ​​defined as the second feature matrix from the first starting position s2 to the first ending position e2. The matrix after clipping. and The [s2:e1] part overlaps, where s1 and s2 represent the first and second start positions, respectively, and e1 and e2 represent the first and second end positions, respectively; T represents the length of the time dimension of the feature matrix, i.e., the number of time steps; Represents the second clipping feature matrix Features of sample i at time step t′ Represents the first clipping feature matrix Features of sample i at time step t Represents the first clipping feature matrix Sample i in Represents the second clipping feature matrix Sample i in Represents the second clipping feature matrix Sample j in;

[0078] The second loss function, loss2, is used to constrain the distance between the feature extractor and the feature extractors from previous training rounds. The formula for calculating the second loss function, loss2, is as follows:

[0079]

[0080] in, These represent the first feature matrices extracted by the local feature extractor of the k-th client in the r-th round. and the first characteristic matrix These represent the first feature matrices extracted by the local feature extractor of the k-th client in the p-th round. and the first characteristic matrix This indicates that each client uses the features extracted by the global feature extractor weights received from the server at the start of training in round r.

[0081] In this embodiment, the length of the feature representation retained after pruning is 32. The data in a batch are pruned from the same starting position and sampled from the uniform distribution U[0,32].

[0082] S32: After the server aggregates the weights of the local feature extractors of all clients, it obtains the global feature extractor weights and distributes these weights to the local feature extractors of each client as the initial weights for the next training round of each client's local feature extractor.

[0083] In S32, the server uses a weighted average method to aggregate the local feature extractor weights of all clients, calculated as follows:

[0084]

[0085] Where k is the client index, |D|, |D k | represents the total data volume of the global client and the data volume of the k-th client, respectively, θ G θ k These represent the weights of the global feature extractor and the local feature extractor of the k-th client, respectively.

[0086] S33: Repeat S31-S32 to update the global feature extractor weights in multiple rounds until the preset number of rounds is reached. Then, distribute the final global feature extractor weights to the local feature extractors of each client, so that each client can obtain the trained local feature extractor.

[0087] In this embodiment, after all three clients have completed feature extractor training and uploaded model weights, the server aggregates these model weights to form new model weights and sends them to the clients. The number of training iterations is set to 40.

[0088] S4: Each client trains a classifier using the labeled dataset under the supervised learning framework to obtain the corresponding client classifier. In each client, the fault diagnosis model is formed by connecting the current feature extractor with the client classifier.

[0089] In S4, each client performs the following steps:

[0090] S41: Input the label dataset into the local feature extractor with updated weights to obtain the feature matrix dataset;

[0091] S42: Use the feature matrix dataset as input to the support vector machine and train the support vector machine to obtain the client classifier.

[0092] S5: After preprocessing, the sensor data of the device to be diagnosed is input into the fault diagnosis model of the corresponding client to obtain the corresponding device diagnosis results.

[0093] In this embodiment, the test set obtained in step S24 is actually the preprocessed data to be diagnosed. The test set data is classified using a fault diagnosis model to obtain the equipment diagnosis results.

[0094] The diagnostic results were compared with the actual results, and accuracy (Acc) and macro-average F1 score (MF1) were selected as evaluation metrics to measure model performance. In this embodiment, the results of these metrics are shown in Table 1.

[0095] Table 1 shows the model performance evaluation table.

[0096]

[0097] Evaluation results show that the method of the present invention can successfully diagnose the device and achieve a high diagnostic accuracy rate, and the method is feasible and effective. Figure 5 , Figure 6 , Figure 7 The confusion matrix of diagnostic results from three clients is shown. It can be seen that although the data distribution differs significantly between each client, the method of this invention achieves extremely high diagnostic accuracy.

[0098] The above embodiments are implementations of the present invention on the Case Western Reserve University bearing fault dataset. However, the specific implementation of the fault diagnosis method of the present invention is not limited to bearings. Any similar scheme that collects equipment operation data through sensors and performs equipment fault diagnosis in accordance with the principles and ideas of the present invention should be considered within the scope of protection of the present invention patent.

Claims

1. A device fault diagnosis method based on federated self-supervised learning, characterized in that, The method comprises the following steps: S1: the server initializes the weight of the feature extractor and distributes the weight to each client, and each client uses the weight as the initial weight of the local feature extractor; S2: each client collects the signal generated by the local device during operation using a sensor and records it as local vibration data, then pre-processes the local vibration data to obtain an unlabeled data set and a labeled data set; S3: under the federated self-supervised learning framework, each client trains the local feature extractor using the unlabeled data set, and then obtains the trained local feature extractor; S3 is specifically: S31: in each round of training, each client trains the local feature extractor using the unlabeled data set under the self-supervised learning framework, obtains the local feature extractor weight of each client after the current round of training, and uploads the weight to the server; S32: the server aggregates the local feature extractor weights of all clients to obtain the global feature extractor weight and distributes the weight to the local feature extractor of each client; S33: repeat S31-S32 to update the global feature extractor weight for multiple rounds until a preset round is reached, and then distribute the final global feature extractor weight to the local feature extractor of each client, so that each client obtains the trained local feature extractor; During training, the local feature extractor outputs a first feature matrix. Second characteristic matrix The gradient descent algorithm is used to optimize the feature extractor weights. The loss function includes a first loss function and a second loss function. The first loss function... The calculation formula is as follows: + wherein, is a batch size, are first and second hyperparameters, respectively, is an indicator function; i and j represent first and second indices of samples in a batch, respectively; is a contextual contrast loss function, is a temporal contrast loss function, denotes a first cropped feature matrix, denotes a second cropped feature matrix, denote first and second starting positions, respectively, denote first and second positions, respectively; denotes a length of a time dimension of a feature matrix; denotes a feature of sample i in a time step of the second cropped feature matrix ; denotes a feature of sample i in a time step of the first cropped feature matrix ; denotes sample i in the first cropped feature matrix ; denotes sample i in the second cropped feature matrix ; denotes sample j in the second cropped feature matrix ; Second loss function The calculation formula is as follows: in, , They represent the first The client number The first feature matrix extracted by the local feature extractor of the round and the first characteristic matrix , , They represent the first The client number The first feature matrix extracted by the local feature extractor of the round and the first characteristic matrix , This indicates that each client uses the [number]th [period]. Features extracted from the global feature extractor weights received from the server during each round of training; S4: each client trains a classifier using the labeled data set under the supervised learning framework to obtain a corresponding client classifier, and in each client, the current local feature extractor and the client classifier are connected to form a fault diagnosis model; S5: the sensor data of the device to be diagnosed is pre-processed and input into the fault diagnosis model of the corresponding client to obtain the corresponding device diagnosis result.

2. The device fault diagnosis method based on federated self-supervised learning according to claim 1, characterized in that, In S1, the feature extractor uses a convolutional neural network with residual connection.

3. The device fault diagnosis method based on federated self-supervised learning according to claim 1, characterized in that, In S2, each client performs the following steps: S21: collect the signal generated by the local device during operation using an accelerometer and record it as local vibration data; S22: randomly select a preset proportion of the local vibration data and label the selected local vibration data according to the actual state of the device to obtain an initial labeled data set, and the unselected local vibration data is recorded as an initial unlabeled data set; S23: use a sliding window to divide all signals of the initial labeled data set and the unlabeled data set into multiple segments to obtain the divided labeled data set and the unlabeled data set; S24: use the maximum-minimum method to scale the divided labeled data set and the unlabeled data set to obtain the final unlabeled data set and the labeled data set.

4. The device fault diagnosis method based on federated self-supervised learning according to claim 1, characterized in that, In S31, each client performs the following steps: S311: use two different data enhancement methods to enhance each piece of unlabeled data in the unlabeled data set to obtain a corresponding enhanced sample pair; S312: train the local feature extractor using the unlabeled data set corresponding to the enhanced sample pair data set under the self-supervised learning framework to obtain the weight of the local feature extractor after the current round of training and upload it to the server.

5. The device fault diagnosis method based on federated self-supervised learning according to claim 4, characterized in that, In the S311, the first data enhanced sample is obtained by adding Gaussian noise to each piece of unlabeled data and then scaling the data with the added noise. Second data augmentation sample is obtained by first smoothly warping the interval of each time step of the unlabeled data, and then applying noise.

6. The device fault diagnosis method based on federated self-supervised learning according to claim 1, characterized in that, In the S32, the server aggregates the local feature extractor weights of all clients using a weighted average method, and the calculation formula is as follows: wherein, is the client index, , denote the data volume of the global client and the data volume of the th client, respectively, denote the weight of the global feature extractor and the local feature extractor weight of the th client, respectively.

7. The device fault diagnosis method based on federated self-supervised learning according to claim 1, characterized in that, In the S4, each client performs the following steps: S51: input the label data set into the local feature extractor with updated weights to obtain a feature matrix data set; S52: input the feature matrix data set as the input of the support vector machine and train the support vector machine to obtain a client classifier.

8. The device fault diagnosis method based on federated self-supervised learning according to claim 1, characterized in that, In the S5, the sensor data of the equipment to be diagnosed is segmented using a sliding window, and after normalization processing using the maximum-minimum method, the sensor data is input into the fault diagnosis model of the corresponding client.

Images