Generalized fault diagnosis method and system for federated domains

Abstract

The present invention proposes a generalized fault diagnosis method and system for a federated domain, and relates to the technical field of fault diagnosis. It includes a plurality of local source clients performing common representation learning on their respective original fault data, extracting convolution features, and refining the extracted convolution features based on a Gaussian transform module, performing important feature enhancement on the refined features through gated attention, and training the local source clients; the central server calculates the gradient of each local source client, clusters the local source clients, optimizes the aggregation process of the gradient within the cluster, and obtains the representative gradient of each cluster; the central server completes the update of the global model based on the representative gradient; iterates the above process until a trained global model is obtained. The present invention uses multiple Gaussian transforms to align fault features from different clients, extracts common representations from different source clients, aligns the model gradients of similar clients, reduces the impact of negative migration and improves generalization capability.

Description

Technical Field

[0001] The present invention belongs to the technical field of fault diagnosis, and in particular to a federated domain generalized fault diagnosis method and system. Background Art

[0002] In recent years, deep learning (DL) has become a key tool in intelligent fault diagnosis, mainly using training and test data from similar statistical distributions. Various DL architectures, such as convolutional neural networks (CNNs), deep belief networks, and long short-term memory networks (LSTMs), have been applied to fault datasets to extract key representations for fault diagnosis. However, different operating conditions and environmental noise often lead to domain shifts between training and test datasets. Therefore, DL-based methods may lose their effectiveness when applied to over-distributed data in real scenarios.

[0003] To address the domain shift problem, multi-source domain generalization (MSDG) has gained attention in fault diagnosis. MSDG aims to exploit data from multiple domains and develop domain-invariant representations with strong generalization capabilities. Recently, diagnosis methods based on federated learning have gained attention to address the data isolation problem. Among them, there are technical solutions that introduce dual classifiers in federated hybrid fault diagnosis, separate mixed fault information into multiple networks, and effectively process data from multiple factories. Another method uses meta-learning and autoencoders to achieve few-shot diagnosis while protecting data privacy. Further federated transfer learning methods have been developed to reduce inter-domain differences and protect data privacy. For example, a multi-source FTL framework is proposed in the prior art, which uses an adversarial mechanism to manage distribution shift while protecting privacy and improves the confidence of pseudo labels through joint voting. A blockchain-based FTL framework is also proposed to improve data privacy and security and eliminate the need for a central server.

[0004] Despite these advances, existing FTL methods still face significant challenges. They often suffer from negative transfer problems due to the difficulty in extracting common representations and indiscriminate model aggregation. These issues limit the effectiveness of FTL methods in real-world applications. Summary of the invention

[0005] To overcome the shortcomings of the above-mentioned prior art, the present invention provides a federated domain generalized fault diagnosis method and system, which uses multiple Gaussian transforms to align fault features from different clients, extract common representations from different source clients, and reduce the gap between domains without the need for target domain labels. In addition, based on the first-order integer neighborhood clustering hierarchical (FINCH) algorithm and the quadratic programming (QP) decomposition method, the model gradients of similar clients are aligned, reducing the impact of negative transfer and improving generalization ability.

[0006] To achieve the above objectives, one or more embodiments of the present invention provide the following technical solutions:

[0007] A first aspect of the present invention provides a federated domain generalized fault diagnosis method.

[0008] The federated domain generalized fault diagnosis method includes the following steps:

[0009] Multiple local source clients obtain their own original fault data respectively;

[0010] Multiple local source clients learn common representations of their respective fault raw data. First, convolutional features are extracted and refined based on the Gaussian transform module. The refined features are enhanced with important features through gated attention to generate a final feature map. Local source clients are trained based on the final feature map.

[0011] Multiple local source clients send their trained local model parameters to the central server;

[0012] The central server calculates the gradient of each local source client, clusters the local source clients based on their gradients, and optimizes the aggregation process of the gradients within the cluster through QP decomposition to obtain the representative gradient of each cluster;

[0013] The central server completes the update of the global model based on the representative gradient;

[0014] The above process is iterated until a trained global model is obtained, and the fault is diagnosed based on the trained global model.

[0015] A second aspect of the present invention provides a federated domain generalized fault diagnosis system.

[0016] The federated domain generalized fault diagnosis system includes:

[0017] The data acquisition module is configured to: multiple local source clients respectively acquire their own original fault data;

[0018] The client learning module is configured as follows: multiple local source clients learn common representations of their respective fault raw data, first extract convolutional features, and refine the extracted convolutional features based on the Gaussian transform module, enhance important features of the refined features through gated attention, generate a final feature map, and train the local source client based on the final feature map;

[0019] The communication module is configured to: a plurality of local source clients send their respective trained local model parameters to a central server;

[0020] The server-side clustering module is configured as follows: the central server calculates the gradient of each local source client, clusters the local source clients based on their gradients, and optimizes the aggregation process of the gradients within the cluster through QP decomposition to obtain the representative gradient of each cluster;

[0021] The update module is configured as follows: the central server completes the update of the global model based on the representative gradient;

[0022] The iteration module is configured to: iterate the above process until a trained global model is obtained, and diagnose the fault based on the trained global model.

[0023] One or more of the above technical solutions have the following beneficial effects:

[0024] The present invention provides a generalized fault diagnosis method and system for a federated domain, and proposes a new generalized framework for a federated domain, GTASA-FDG, which uses multiple Gaussian transforms to align fault features from different clients, reducing the gap between domains without the need for target domain labels. The model maps fault features through multiple Gaussian functions to extract common representations from different source clients. In addition, GTASA-FDG adopts an adaptive model aggregation algorithm based on the first-order integer neighborhood clustering hierarchy (FINCH) algorithm and the quadratic programming (QP) decomposition method to align the model gradients of similar clients, reducing the impact of negative transfer and improving generalization capabilities. GTASA-FDG solves the shortcomings of existing methods and provides a more flexible solution for multi-source federated fault diagnosis.

[0025] Advantages of additional aspects of the present invention will be given in part in the following description, and in part will become obvious from the following description, or will be learned through practice of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0026] The accompanying drawings in the specification, which constitute a part of the present invention, are used to provide a further understanding of the present invention. The exemplary embodiments of the present invention and their descriptions are used to explain the present invention and do not constitute improper limitations on the present invention.

[0027] Figure 1 This is a flow chart of the method of the first embodiment. DETAILED DESCRIPTION

[0028] It should be noted that the following detailed descriptions are exemplary and are intended to provide further explanation of the present invention. Unless otherwise specified, all technical and scientific terms used herein have the same meanings as those commonly understood by those skilled in the art to which the present invention belongs.

[0029] It should be noted that the terms used herein are for describing specific embodiments only and are not intended to be limiting of exemplary embodiments according to the present invention.

[0030] In the absence of conflict, the embodiments of the present invention and the features of the embodiments may be combined with each other.

[0031] Embodiment 1

[0032] Federated transfer learning solves the domain difference problem in intelligent fault diagnosis while protecting the confidentiality of data, but it often suffers from poor generalization and negative migration during model aggregation. To address these challenges, this embodiment proposes a federated domain generalization framework (GTASA-FDG) based on Gaussian transform and adaptive similarity aggregation. GTASA-FDG uses a Gaussian transform mechanism to dynamically adjust the feature distribution of different clients and enhance the alignment of fault features between different domains. In addition, the framework also combines an adaptive similarity-based model aggregation strategy, using a first-order integer neighborhood clustering hierarchical algorithm and a quadratic programming decomposition method to selectively aggregate model gradients from similar clients. This targeted aggregation method reduces the impact of negative migration and improves the generalization ability for unseen and changing operating conditions. Extensive experiments on two datasets of rolling bearings and experimental rolling bearings have verified the superiority of GTASA-FDG over existing state-of-the-art diagnostic methods, demonstrating its effectiveness and robustness in real applications.

[0033] like Figure 1 As shown, the federated domain generalized fault diagnosis method provided in this embodiment includes the following steps:

[0034] Multiple local source clients obtain their own original fault data respectively;

[0035] Multiple local source clients learn common representations of their respective fault raw data. First, convolutional features are extracted and refined based on the Gaussian transform module. The refined features are enhanced with important features through gated attention to generate a final feature map. Local source clients are trained based on the final feature map.

[0036] Multiple local source clients send their trained local model parameters to the central server;

[0037] The central server calculates the gradient of each local source client, clusters the local source clients based on their gradients, and optimizes the aggregation process of the gradients within the cluster through QP decomposition to obtain the representative gradient of each cluster;

[0038] The central server completes the update of the global model based on the representative gradient;

[0039] The above process is iterated until a trained global model is obtained, and the fault is diagnosed based on the trained global model.

[0040] In the FDG task, the data includes several source clients and one target client. In this embodiment, it is assumed that the clients may be under different working conditions. These M source clients are defined as , Indicates the source client, represents the mth source client, represents the totality of the data set, represents the original data set of the mth source client, and M represents the number of source clients.

[0041] Meanwhile, the target client consists of a target domain, defined as , represents the target domain, where represents the unlabeled target domain, Indicates samples of the target domain, Represents the number of samples in the target domain.

[0042] The target domain is not available during the training phase of the FDG task. This embodiment assumes that the label space of all source clients is the same (i.e., , represents the total label space, Indicates the label space of the first source client, Indicates the label space of the second source client, represents the label space of the mth source client). Meanwhile, the target client satisfies , and They represent the label space of the source client and the label space of the target domain respectively.

[0043] Feature representation mapping of source client First, we define a common representation learning framework, where S represents the source domain and aims to obtain domain-invariant representations by eliminating distribution differences in the feature space. This embodiment aims to learn a feature representation mapping , to eliminate the distribution differences between the two source clients. By using the proposed commonality representation learning framework, it can be achieved , represents the source domain dataset, Represents the target domain dataset.

[0044] At the same time, the classifier It is expected that the classification risk of the source domain will be minimized through supervised training. The formula is , where each symbol represents: represents an unoptimized classifier; Indicates source domain samples and their label pairs; Represents the feature input of the i-th source domain sample; represents the label of the i-th source domain sample; represents the mathematical expectation, Represents the features of the i-th source domain sample, which is used to obtain the output result through the classifier f; Indicates The true labels of source domain samples and The outputs of are compared to calculate the classification risk; It means the The features of source domain samples are passed through the classifier The output result after represents the hypothesis space. After training the framework, domain-invariant but discriminative features can be extracted to accurately diagnose faults in unseen target domain samples.

[0045] Figure 1 This is the overall framework flow chart of the present invention. This embodiment combines the Gaussian transform for common representation learning with model aggregation based on adaptive similarity. Overall, first, multiple Gaussian functions are used to transform and align fault features from different source clients, reduce inter-domain differences and enhance feature representation without the need for data from the target domain. Next, the model aggregation strategy based on adaptive similarity clusters client models through FINCH, and optimizes the aggregation process through QP, selectively merging compatible models to prevent negative transfer. This two-step approach ensures that the model has strong generalization capabilities under diverse and unknown working conditions, and improves the effectiveness of the model in real-world federated learning scenarios.

[0046] 1. Gaussian Transformation for Commonality Representation Learning

[0047] The Gaussian Transformation module is a key component of the framework, which aims to enhance feature representation through the combination of convolutional feature extraction, multiple Gaussian functions and gated attention operations. This approach allows the model to capture and represent data distribution more effectively, thereby improving generalization performance.

[0048] make represents the input signal of the i-th sample of the source client, where represents the source domain, Indicates target objects. Convolutional neural networks (CNNs), denoted as CNNs, are used to capture high-level and low-level features across multiple scales. The convolutional layer is defined as follows:

[0049]

[0050] in Represents the feature map extracted by CNN.

[0051] The CNN architecture consists of multiple convolutional layers, each followed by a max pooling operation to reduce dimensionality and retain important features. Figure 1 As shown in Figure 2, CNN uses convolution kernels of different sizes to ensure that both fine-grained and coarse-grained features are captured.

[0052] After completing the convolution feature extraction, the Gaussian transform module applies multiple Gaussian functions to further refine the features. Each Gaussian function is composed of its mean and standard deviation Parameterized, and all are trainable parameters. The first Gaussian transform is defined as:

[0053]

[0054] in is the mean, is the standard deviation. It is the feature map after the first Gaussian transformation.

[0055] The Gaussian Transform module also extends the Gaussian Transform by introducing two Gaussian functions. This allows the model to capture more complex feature distributions. The second Gaussian Transform is defined as:

[0056]

[0057] in, is the feature map after the second bimodal Gaussian transform, represents the mean of the first Gaussian function, represents the mean of the second Gaussian function, represents the standard deviation of the first Gaussian function, represents the standard deviation of the second Gaussian function.

[0058] These transformations are applied independently to the feature maps. , thus generating two transformed feature maps and , and passed to the next stage.

[0059] After Gaussian transformation, the feature map is further processed by a gated attention mechanism, which aims to selectively enhance important features while suppressing irrelevant features based on the context provided by the transformed features.

[0060] Feature Map and It is divided into two parts along the channel axis. These parts are then fused to form a new feature map that combines the Gaussian and bimodal Gaussian transform information:

[0061] , (4)

[0062] , (5)

[0063] in, Indicates the fusion of features after different Gaussian transformations; Indicates the source domain Feature map of samples Feature representation after Gaussian transformation operation; Indicates the source domain Feature map of samples Feature representation after bimodal Gaussian transform operation; Indicates the source domain Another feature map of samples Feature representation after Gaussian transformation operation; Indicates the source domain Another feature map of samples Feature representation after bimodal Gaussian transform operation; and Represents the fused features.

[0064] The fused features and This is processed via a gating mechanism that applies dynamic soft selection based on the importance of each feature:

[0065] , (6)

[0066] , (7)

[0067] , (8)

[0068] in and denote gating selections that highlight the most salient features for subsequent classification. express Function, used to normalize features and generate weight distribution; Represents the addition operation; Represents a multiplication operation.

[0069] The Softmax gating mechanism ensures that the most relevant features extracted from the fused input are enhanced while reducing the influence of irrelevant features.

[0070] Gating Features and Then the final feature map is generated by adding the elements one by one. , this feature map combines the information of all previous transformations:

[0071] , (9)

[0072] Output , and It is then passed as input to the fully connected layers and classification layers. This ensures that the model exploits the rich representation of the data. This approach allows the network to focus on the global distribution of features. After the model is aggregated on the server, all participating clients share the same Gaussian distribution from the source client, thereby improving the model's generalization ability across different domains.

[0073] Classification loss for local model training It is expressed as:

[0074] , (10)

[0075] in represents the true label, Indicates the prediction result. represents the sparse categorical cross entropy loss function.

[0076] 2. Model Aggregation Based on Adaptive Similarity

[0077] In federated learning, effectively aggregating locally trained models is crucial to building a robust and generalizable global model. Traditional methods (such as FedAvg) rely on simple weighted averaging, which may perform poorly when the client data distribution varies greatly. To address this problem, this embodiment proposes an adaptive similarity-based aggregation strategy that combines FINCH-based client model clustering and optimizes the aggregation process through QP decomposition. This approach enhances the stability and performance of the global model.

[0078] When the server receives the updated model from the client, it first calculates the gradient relative to the global model. For the kth round of communication, let represents the weight of the global model in the kth round of communication, where the subscript g means "global", indicating that the weight here is the weight of the global model; represents the weight of the model of the mth client in the kth round of communication. The gradient of client m in the kth round of communication The calculation is as follows:

[0079] , (11)

[0080] Here, g not in a subscript position represents a gradient.

[0081] When the gradient calculations for all clients are completed, the server uses the FINCH algorithm to dynamically group similar clients. FINCH does not require preset parameters and automatically determines the clustering structure based on the nearest neighbor relationship, which makes it very suitable for handling federated learning with variable client data distribution. FINCH essentially selects representative model gradients because model gradients trained on different domains are unlikely to be each other's nearest neighbors. Therefore, gradients from different domains are unlikely to be grouped together, while gradients from similar domains naturally form clusters. Specifically, the algorithm calculates the cosine similarity between each pair of client gradients, identifies the gradient with the highest similarity as a "neighbor", and assigns it to the corresponding cluster.

[0082] To describe this process, we define the adjacency matrix of the kth round of communication as as follows:

[0083] (12)

[0084] in, represents the adjacency matrix for determining the similarity relationship between client m and client n in the kth round of communication; represents the model gradient of client n in the kth round of communication; m and n are used to distinguish different clients.

[0085] Based on this clustering method, a representative gradient is selected in the embedding space according to the clustering results given by the above adjacency matrix. The clustering gradient is denoted as , expressed as:

[0086] , (13)

[0087] , (14)

[0088] in, represents the number of clusters formed in the kth round of communication, Indicates Cluster gradients in round communication, Indicates In the round of communication, the first to the The representative gradient of each cluster.

[0089] Through this process, The model gradients of the clients are adaptively clustered into This cluster-driven aggregation effectively addresses the differences in client data distribution and enhances the stability and performance of the global model in a federated learning environment.

[0090] For each determined cluster, the proposed method uses the QP problem (Quadratic Programming) to optimize the aggregation of gradients within the cluster. The QP problem is defined as follows:

[0091] , (15)

[0092] The constraints are:

[0093] , (16)

[0094] in, is the quadratic term matrix, Indicates The concatenation of the client gradients in the clusters. The factor 2 is used to ensure the correct formulation of the QP problem. The vector A is a row vector of 1s, ensuring that the weights The sum of is equal to 1. The expression is as follows:

[0095] , (17)

[0096] Scalar The value of is 1:

[0097] , (18)

[0098] Q is a negative identity matrix, ensuring that the weights are non-negative (i.e. ). The matrix is ​​defined as follows:

[0099] , (19)

[0100] where I is the identity matrix and h is defined as:

[0101] , (20)

[0102] where L is a vector whose entries are ,here, It is used to adjust the initial weight A value that ensures that the weight remains in the interval [0, 1]; represents the initial weight of the gradient of each client in the cluster, calculated as the proportion of the total amount of data represented by each client; represents the i-th client in the cluster, and i represents the i-th target object. Specifically, Defined as:

[0103] ,(twenty one)

[0104] in It is The amount of data per client, is the total amount of data from all clients. The proposed method uses QP decomposition to optimize the gradient aggregation process in clustering by adjusting the gradient weights. The QP problem reduces the alignment error between client gradients, thereby achieving robust aggregation. The constraints ensure that the weights are non-negative, normalized, and allocated based on the amount of data from each client. This method balances the gradient contributions and improves the generalization ability of the aggregation model in different and unknown scenarios.

[0105] Once the weights are obtained, the gradients in clustering will use the optimized weights For a given cluster , the aggregate gradient is calculated as follows:

[0106] ,(twenty two)

[0107] in, For clustering Representative gradient of represents the i-th cluster; It is clustering The number of local source clients in; is assigned to The weight of the client gradient, Representation clustering Middle Model gradients for each client; Indicates Clients.

[0108] After aggregating the gradients within the clusters, the server aggregates the gradients between clusters according to the proportion of data represented by each cluster. The global model is updated as follows:

[0109] ,(twenty three)

[0110] in, represents the weight of the global model of the kth round of communication; represents the weight of the global model of the k+1th round of communication; Represents the number of clusters formed in the kth round of communication.

[0111] This process will run for a predetermined number of rounds. In each round, the steps of similarity calculation, clustering, QP decomposition, and model aggregation are repeated to gradually optimize the global model. The robustness of the aggregation process is ensured by dynamically adjusting the clustering threshold and adapting to changes in client data distribution.

[0112] like Figure 1 As shown, first, the local clients obtain their own original fault data respectively; this step corresponds to Figure 1"Source Client 1...Source Client M" at the top left of the middle;

[0113] Afterwards, multiple local source clients learn the common representation of their respective fault raw data. This process corresponds to Figure 1 The “Gaussian Transformation for Commonality Representation Learning” in the lower middle left;

[0114] In the "Gaussian Transformation for Common Representation Learning", the feature extractor extracts convolutional features through alternating convolutional layers and maximum pooling layers, and finally inputs the convolutional features into the "Gaussian Transformation Module" on the lower left. The convolutional features are refined using two Gaussian transformations. Figure 1 The Gaussian transform on the upper left side corresponds to the first Gaussian transform in this embodiment. Figure 1 The two Gaussian transforms on the lower left side of the figure correspond to the second bimodal Gaussian transform. Finally, the fused features are obtained through the Gaussian transform module to form a new feature map that combines Gaussian and bimodal Gaussian transform information.

[0115] The fused features are input into Figure 1 In the gated attention mechanism on the left, important features are enhanced through gated attention to generate the final feature map;

[0116] Training the local source client based on the final feature map;

[0117] After one round of training, the local clients send their trained local model parameters to the central server, and the central server receives the model parameters. This process corresponds to Figure 1 The "Model w" on the top right 1 ...Model w M ”;

[0118] After that, the central server calculates the gradient of each local source client and clusters the local source clients based on their gradients. This process corresponds to Figure 1 In the "Clustering based on cosine similarity" on the middle right, circles of different colors are clustered into different clusters;

[0119] Afterwards, the aggregation of gradients within clusters is optimized through QP decomposition to obtain the representative gradient of each cluster;

[0120] Finally, the central server completes the update of the global model based on the representative gradient. This process corresponds to Figure 1 "Global Model Aggregation" on the right side of the middle, thus completing a round of training.

[0121] 3. Experimental part

[0122] The experiments were conducted on two rolling bearing datasets. The first dataset is the Paderborn dataset, which collects data from damaged and healthy rolling bearings. Three health states were used in the experiment, including healthy (H), inner ring (IR) damaged, and outer ring (OR) damaged bearings. The data in each health state were collected under four different operating conditions, as shown in Table 1. In this embodiment, the original signal of the Paderborn dataset is divided into slices of the same length and then input into the classification network. Each slice contains 4096 points and does not overlap.

[0123] The second dataset is an experimental rolling bearing dataset, which is collected by a test bench designed using the GUNT PT500 mechanical diagnostic system. The sampling rate of all data is 25.6 kHz. The experimental dataset includes data of rolling bearings in healthy, inner ring damaged, and outer ring damaged conditions. The data in each health state is collected at different speeds (between 900 rpm and 2000 rpm). The working setup and data encoding are detailed in Table 1.

[0124] In the experiment, data from different working conditions are used to train the global federated learning model. To avoid data imbalance, all clients use 2000 samples for training and testing.

[0125] Table 1: Operation conditions of Paderborn dataset and experimental dataset

[0126]

[0127] In order to evaluate the effectiveness of the key modules in GTASA-FDG, an ablation study is performed on the rolling bearing dataset to evaluate the impact of different components in GTASA-FDG (Gaussian transform, gated attention mechanism, adaptive similarity aggregation).

[0128] Table II shows the quantitative results of the ablation study. The results show that removing the Gaussian transform module (M1) leads to a significant performance drop in all tasks. This highlights the key role of the Gaussian transform in improving feature representation and promoting generalization by mapping the input features to a more informative space. In addition, excluding the gated attention mechanism (M2) also leads to a significant drop in accuracy. This suggests that the attention mechanism effectively captures relevant features while filtering out irrelevant information, thereby enhancing the discriminative ability of the model. Finally, removing the adaptive similarity aggregation (M3) component leads to the most significant performance drop. This finding emphasizes the importance of adaptive aggregation, which can align model updates from different clients and ensure more consistent and stable training across different domains.

[0129] Table 2 shows the accuracy achieved by various state-of-the-art methods during federated learning. The results clearly show that GTASA-FDG outperforms all compared methods, demonstrating its superior ability in cross-domain generalization. For example, on the rolling bearing dataset, GTASA-FDG achieves the highest accuracy, consistently outperforming other methods such as FedAvg, FedProx, MOON, FedBN, and FedDGFD.

[0130] FedAvg and FedProx perform poorly in dealing with domain shift due to their limited performance of basic aggregation techniques. MOON improves slightly by incorporating contrastive learning, but still cannot effectively deal with the domain difference problem. FedBN improves performance by introducing client-level batch normalization on each client, but still underperforms GTASA-FDG. FedDGFD achieves competitive results through its domain generalization method, but still underperforms GTASA-FDG.

[0131] Table 2: Comparison of experimental results on Paderborn and experimental datasets

[0132]

[0133] Note: Bold values ​​indicate the best results.

[0134] Embodiment 2

[0135] This embodiment discloses a federated domain generalized fault diagnosis system.

[0136] The federated domain generalized fault diagnosis system includes:

[0137] The data acquisition module is configured to: multiple local source clients respectively acquire their own original fault data;

[0138] The client learning module is configured as follows: multiple local source clients learn common representations of their respective fault raw data, first extract convolutional features, and refine the extracted convolutional features based on the Gaussian transform module, enhance important features of the refined features through gated attention, generate a final feature map, and train the local source client based on the final feature map;

[0139] The communication module is configured to: a plurality of local source clients send their respective trained local model parameters to a central server;

[0140] The server-side clustering module is configured as follows: the central server calculates the gradient of each local source client, clusters the local source clients based on their gradients, and optimizes the aggregation process of the gradients within the cluster through QP decomposition to obtain the representative gradient of each cluster;

[0141] The update module is configured as follows: the central server completes the update of the global model based on the representative gradient;

[0142] The iteration module is configured to: iterate the above process until a trained global model is obtained, and diagnose the fault based on the trained global model.

[0143] Those skilled in the art should understand that the modules or steps of the present invention described above can be implemented by a general-purpose computer device, or alternatively, they can be implemented by a program code executable by a computing device, so that they can be stored in a storage device and executed by the computing device, or they can be made into individual integrated circuit modules, or multiple modules or steps therein can be made into a single integrated circuit module for implementation. The present invention is not limited to any specific combination of hardware and software.

[0144] Although the above describes the specific implementation mode of the present invention in conjunction with the accompanying drawings, it is not intended to limit the scope of protection of the present invention. Those skilled in the art should understand that various modifications or variations that can be made by those skilled in the art on the basis of the technical solution of the present invention without creative work are still within the scope of protection of the present invention.

Claims

1. A generalized fault diagnosis method for a federated domain, characterized in that: The following steps are involved: Multiple local source clients obtain their own original fault data respectively; Multiple local source clients learn common representations of their respective fault raw data. First, convolutional features are extracted and refined based on the Gaussian transform module. The refined features are enhanced with important features through gated attention to generate a final feature map. Local source clients are trained based on the final feature map. Multiple local source clients send their trained local model parameters to the central server; The central server calculates the gradient of each local source client, clusters the local source clients based on their gradients, and optimizes the aggregation process of the gradients within the cluster through QP decomposition to obtain the representative gradient of each cluster; The central server completes the update of the global model based on the representative gradient; Iterate the above process until a trained global model is obtained, and diagnose the fault based on the trained global model; The aggregation process of the gradient within the cluster is optimized through QP decomposition to obtain the representative gradient of each cluster, including: obtaining the optimized weight of the local source client in each cluster through QP decomposition ; Use the optimized weights Aggregate the local source client gradients within each cluster: ； in, For clustering Representative gradient of represents the i-th cluster; It is clustering The number of local source clients in; is assigned to The weight of the client gradient; Representation clustering Middle Model gradients for each client; Indicates Clients; The optimized weights of local source clients in each cluster are obtained through QP decomposition , including: The QP problem is defined as follows: ； The constraints are: ； in, is the quadratic term matrix, Indicates The concatenation of the client gradients in the clusters; the vector A is a row vector of 1s, a scalar The value of is 1, Q is a negative identity matrix; , L is a vector.

2. The federated domain generalized fault diagnosis method according to claim 1, characterized in that: The convolution features extracted based on the Gaussian transform module are refined, including: Use the first Gaussian transform to refine the convolutional features and obtain the transformed feature map ; The convolution feature is refined using the second bimodal Gaussian transform to obtain the transformed feature map .

3. The federated domain generalized fault diagnosis method according to claim 2, characterized in that: Also includes: The feature map and The images are divided into two parts along the channel axis, and the corresponding parts of the two parts are fused respectively to obtain the fused features, forming a new feature map that combines Gaussian and bimodal Gaussian transform information.

4. The federated domain generalized fault diagnosis method according to claim 3, characterized in that: The refined features are enhanced through gated attention to generate the final feature map, including: ； ； ； ； in, and represents gate selection; and is the fused feature; represents the final feature map; express function; Represents the addition operation; Represents a multiplication operation.

5. The federated domain generalized fault diagnosis method according to claim 4, characterized in that: The training of the local source client is performed based on the final feature map, including: Will , and As input, it is passed to the fully connected layer and classification layer to complete the training of the local source client; Classification loss for local source client training It is expressed as: ； in, represents the true label, Indicates the prediction result; represents the sparse categorical cross entropy loss function.

6. The federated domain generalized fault diagnosis method according to claim 1, characterized in that: The central server calculates the gradient of each local source client and clusters the local source clients based on their gradients, including: For the kth round of communication, the gradient of the local source client m is the difference between the weight of the global model and the weight of the mth local model; Calculate the cosine similarity between each pair of local source client gradients, set the similarity threshold, and complete the clustering of local source clients.

7. The federated domain generalized fault diagnosis method according to claim 1, characterized in that: The central server completes the update of the global model based on the representative gradient, specifically: ； in, represents the weight of the global model in the kth round of communication, represents the weight of the global model in the k+1th round of communication. The g in the subscript position represents the global model, and the g not in the subscript position represents the gradient. Represents the number of clusters formed in the kth round of communication.

8. A federated domain generalized fault diagnosis system, based on the federated domain generalized fault diagnosis method according to any one of claims 1 to 7, characterized in that: include: The data acquisition module is configured to: multiple local source clients respectively acquire their own original fault data; The client learning module is configured as follows: multiple local source clients learn common representations of their respective fault raw data, first extract convolutional features, and refine the extracted convolutional features based on the Gaussian transform module, enhance important features of the refined features through gated attention, generate a final feature map, and train the local source client based on the final feature map; The communication module is configured to: a plurality of local source clients send their respective trained local model parameters to a central server; The server-side clustering module is configured as follows: the central server calculates the gradient of each local source client, clusters the local source clients based on their gradients, and optimizes the aggregation process of the gradients within the cluster through QP decomposition to obtain the representative gradient of each cluster; The update module is configured as follows: the central server completes the update of the global model based on the representative gradient; The iteration module is configured to: iterate the above process until a trained global model is obtained, and diagnose the fault based on the trained global model.

Images