Heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis

Abstract

The invention discloses a heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis, and the method comprises the steps: carrying out the two-stage federated learning based on a multi-agent generative adversarial network MAD-GAN frame for the fault detection of a bearing vibration signal; in the first stage, the MAD-GAN model is trained in the federated learning environment, the data sample expansion process can effectively relieve the modal collapse problem, and in the second stage, the federated MAD-GAN model is utilized to generate data samples with high quality and diversity for a client, so that federated learning model training is performed, and the generalization ability and diagnosis precision of the model are improved. In order to further reduce communication overhead, an advanced model compression technology is introduced in the second stage of the invention, and a sparse method and a quantization method such as Top-k are combined. Redundancy in the communication process can be eliminated, the data transmission quantity is reduced, the problem of non-independent identically distributed data in industrial fault diagnosis can be solved, and the communication efficiency is remarkably improved.

Description

Technical Field

[0001] The present invention belongs to the field of industrial fault diagnosis, and particularly relates to an efficient federated learning method for heterogeneous data in intelligent manufacturing fault diagnosis. Background Art

[0002] In-depth research on fault diagnosis in industrial scenarios has made equipment more reliable and easier to maintain, thus significantly extending its service life and effectively avoiding serious industrial safety accidents. Relevant research results have been widely applied in the core fields of product intelligence, such as integrated circuit manufacturing, aviation equipment, marine engineering equipment, and rail transit equipment. With the rapid development of intelligent data-driven mechanical fault diagnosis theory and technology, significant breakthroughs have been made in recent years in aspects such as fault feature extraction, diagnosis, and life prediction. In particular, the development of artificial intelligence technology and the accumulation of massive monitoring data have enabled machine learning methods to exhibit excellent performance and extremely high accuracy in fault diagnosis.

[0003] However, despite the success of intelligent diagnosis methods, most existing methods rely too much on complete fault data sets to improve generalization performance. In actual industrial scenarios, considering economic and time factors, it is often difficult to collect sufficient training data. This situation restricts the application of intelligent diagnosis methods in actual industries. A feasible option is to directly aggregate multiple users' data, which can greatly save economic and time costs. However, in practice, due to issues such as industry competition, interest conflicts, and privacy security, there are barriers that are difficult for industry users to break through between data sources. In addition, different users may have heterogeneous data, which is difficult to integrate and utilize. For example, vibration data and current signals can be obtained separately by different industrial customers, and it is not straightforward to directly use different types of data to obtain better performance. These challenges are called the data island problem, which usually occurs in different industries. Therefore, there is an urgent need to develop a collaborative solution that can protect data privacy and improve data utilization efficiency to achieve cross-industry and cross-domain data sharing and promote the innovation and application of industrial fault diagnosis technology.

[0004] In the industrial field, the emergence of federated learning technology provides an innovative solution for multi-data collaboration and privacy protection. Its essence is a distributed machine learning technology. Only through the transmission of models and knowledge, it can implicitly centralize the distributed data information of multiple users, while strictly ensuring that the local private data of each user cannot be accessed by other users and the central server, forming a collaborative modeling framework that guarantees data privacy. Compared with traditional centralized learning, federated learning technology does not require centralized collection of raw data, nor does it involve subsequent data transmission and public sharing, which can ensure data privacy. Existing research has shown that under the independent and identically distributed (IID) setting, the aggregated updates of federated learning are unbiased estimators of local updates. Unfortunately, in real industrial scenarios, data is often non-independent and identically distributed (non-IID), and this distribution characteristic leads to a significant increase in model performance degradation and communication cost problems, becoming the key challenge restricting the application of federated learning in the industrial field. Therefore, how to ensure the performance of the federated learning model under non-IID data while reducing the communication overhead has become an important research topic currently.

[0005] Currently, to alleviate the non-IID problem in federated learning, generative adversarial networks (GANs) are applied to FL (federated learning technology) to supplement the missing datasets in the clients. Among them, GAN includes a discriminator and a generator. The goal of the discriminator is to evaluate the likelihood that the generated samples are real or fake, which in turn trains the generator to improve its performance. The learned generator simulates IID samples to enhance local non-IID data. However, in existing GAN-based solutions, the samples generated by the generator lack diversity, which will lead to the problem of mode collapse. To solve this problem, Ghosh et al. proposed MAD-GAN to solve the well-known mode collapse problem through multiple generators. Xu et al. proposed a data fusion diagnosis scheme based on the bearing dynamic model and MAD-GAN, demonstrating the advantages of MAD-GAN data augmentation and alleviating mode collapse in the industrial field. However, the above research is based on the traditional centralized environment and does not fully consider the complexity of multi-data source collaboration. In the case of multi-data source collaboration, Xin et al. proposed to make GAN obtain a more comprehensive data distribution to prevent mode collapse by exchanging the trained discriminators between users. However, communication based on users is not suitable for the federated architecture. Ma et al. proposed a joint GAN algorithm using a divide-and-conquer strategy. The server alleviates the problem of model collapse in the non-IID setting by distributing generators to generate diverse data for each client, but does not consider the communication overhead problem of the overall data collaboration scheme. Summary of the Invention

[0006] To solve the above problems existing in the prior art, the present invention provides an efficient federated learning method for heterogeneous data in intelligent manufacturing fault diagnosis. The technical problems to be solved by the present invention are realized through the following technical solutions:

[0007] In a first aspect, an embodiment of the present invention provides an efficient federated learning method for heterogeneous data in intelligent manufacturing fault diagnosis, which is applied to a federated learning system composed of a server and multiple clients. Each client is provided with a local MAD-GAN model and a federated learning model; the method includes:

[0008] S1, each client downloads and initializes the weights of the local MAD-GAN model and the weights of the federated learning model from the server;

[0009] S2, in the current round of training, each client uses private data and, through a two-stage training method of local local training and server global aggregation, trains the local MAD-GAN model multiple times until a trained federated MAD-GAN model is obtained; among them, the private data of each client includes multiple samples, and each sample is a bearing vibration signal with a label, and the label includes a normal state or a fault type;

[0010] S3, each client uses the obtained federated MAD-GAN model to generate sample-balanced Non-IID data, thereby realizing the expansion of private data;

[0011] S4, each client uses the expanded private data and the weights of the federated learning model obtained in the current round to train the local federated learning model, and obtains the local updated model parameters of the local federated learning model in the current round of training;

[0012] S5, each client compresses the local updated model parameters of the local federated learning model in the current round of training by using a sparsification method and a quantization method, and sends the compressed model parameters to the server;

[0013] S6, the server updates the weights of the federated learning model according to the compressed model parameters uploaded by all clients in the current round of training, and distributes them to each client;

[0014] S7, according to the newly distributed weights of the federated learning model by the server, execute S4-S6 again until the number of training rounds reaches the maximum number of rounds, and obtain a trained global federated learning model for fault detection of the to-be-tested bearing vibration signal.

[0015] In a second aspect, an embodiment of the present invention provides a federated learning system, which includes a server and multiple clients. Each client is provided with a local MAD-GAN model and a federated learning model. The federated learning system uses the heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis described in the first aspect to obtain a trained global federated learning model for fault detection of the vibration signal of the bearing to be measured.

[0016] The present invention discloses a heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis and a federated learning system. For the fault detection of bearing vibration signals, the present invention performs two-stage federated learning based on the multi-agent generative adversarial network (MAD-GAN) framework. The first stage is to train the MAD-GAN model in a federated learning environment. Through multiple interactions of local local training and server global aggregation, a trained federated MAD-GAN model is obtained. The second stage is to use the federated MAD-GAN model to generate data samples with high diversity and quality for each client, and then train the federated learning model through the interaction between the local and the server to obtain a trained global federated learning model for fault detection of the vibration signal of the bearing to be measured. The process of using the federated MAD-GAN model to expand the local private data of the client effectively alleviates the mode collapse problem and improves the generalization ability and diagnostic accuracy of the model. To further reduce the communication overhead, before transmitting the parameters to the server in the second stage of the present invention, an advanced model compression technology is introduced, which combines sparsification methods such as Top-k and quantization methods. The Top-k algorithm selects the most important model parameters for transmission, and the quantization technology further reduces the representation accuracy of these parameters, thereby eliminating the redundancy in the communication process and reducing the data transmission volume. The present invention can solve the problem of non-independent and identically distributed data in industrial fault diagnosis and significantly improve the communication efficiency. Description of the Drawings

[0017] Figure 1 It is a framework diagram of the federated learning system;

[0018] Figure 2 It is a schematic diagram of the standard GAN structure;

[0019] Figure 3 It is a typical architecture diagram of MAD-GAN;

[0020] Figure 4 It is a schematic flow diagram of a heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis provided by an embodiment of the present invention;

[0021] Figure 5 It is the performance of the average test accuracy of 10 clients after 200 rounds of iteration on the STU dataset under different sparsity rates for the method of the embodiment of the present invention;

[0022] Figure 6 shows the model compression process of the present invention;

[0023] Figure 7 is a schematic diagram of the principle of the SQC-FLMGAN framework provided by the embodiments of the present invention;

[0024] Figure 8 is a schematic diagram of the CWRU test platform in the experiment of the present invention;

[0025] Figure 9 is a schematic diagram of the detailed information of the bearing fault implantation test bench and bearing fault types in the experiment of the present invention;

[0026] Figure 10 is the data distribution of the client in the experiment of the present invention;

[0027] Figure 11 is a comparison chart of the generated frequency signal and the real frequency signal in the experiment of the present invention;

[0028] Figure 12 is a comparison chart of the test accuracy and communication overhead under different methods in the experiment of the present invention. Detailed Embodiments

[0029] The present invention will be further described in detail below in conjunction with specific embodiments, but the embodiments of the present invention are not limited thereto.

[0030] To facilitate understanding of the solution of the present invention, relevant knowledge of federated learning and multi-agent multi-generative adversarial network will be briefly described first.

[0031] Federated learning is a machine learning method designed for training data scattered and stored on multiple clients (such as mobile devices). Different from traditional centralized and decentralized architectures, the characteristic of federated learning is that the local data sets of each client cannot represent the overall data distribution. Generally, clients use machine learning models such as neural networks and perform local model training through specific algorithms, and aggregate all local models to achieve data value sharing as Figure 1 shown. Figure 1 is a framework diagram of the federated learning system. The objectives of federated learning are as follows:

[0032]

[0033] Among them, F k (W k ) is the local objective function, and F(W) is the global objective function.

[0034] In the t-th training iteration of federated learning, each user first downloads the current global model W t, train a local model on local data and pass the local update information to the central server for aggregation. Given K clients, consider the following FL aggregation algorithms:

[0035] FedAvg: In each round of iteration, the K clients participating in the update perform SGD iteration E epochs locally, and then upload the model to the server side (Server) for aggregation. As follows:

[0036]

[0037] where n represents the global data volume, n k represents the local data volume of the k-th client.

[0038] FedProx: On the basis of FedAvg, a proximal term is added to ensure that the local update does not deviate too far from the initial global model. The optimization objective is as follows:

[0039]

[0040] where F k (W k ) is the local objective of the k-th device, and W t is the model parameter on the Server side after t rounds of iteration.

[0041] The server collects the updated model parameters from each client and performs model aggregation operations, and then redistributes the aggregated model to the clients for multiple rounds of communication until a certain number of training rounds are reached.

[0042] Generative adversarial network is a machine learning framework that is widely used in data synthesis technology to generate fake real samples similar to the initial samples. Figure 2 The schematic diagram of the standard GAN structure is given. This structure consists of a generator G and a discriminator D. The generator G is a probability distribution generation function that learns to convert the random noise z into a distribution close to real numbers. The discriminator D is a classifier whose purpose is to classify the input data into two categories: true and false. Its objective function is:

[0043]

[0044] where z represents the noise input of the generator, and θ and w represent the parameters of the generator and discriminator models respectively. minmaxV(G,D) includes maxV(D,G) and minV(D,G), which respectively represent optimizing the discriminator D to distinguish the generated data G(z), and optimizing the generator G so that the discriminator D cannot distinguish the generated data G(z).

[0045] However, problems such as mode collapse, insufficient diversity of generated samples, and vanishing gradients often occur in the original GAN. Due to the uncontrollability of the adversarial training process, the generation performance of the GAN model is unstable. Mode collapse is a huge early danger during the GAN training stage, which causes the generated fake samples to lose diversity. An important factor leading to this problem is the imbalance of the adversarial mechanism and the large difference in the initial distributions between the generated samples and the actual samples. The multi-agent generative adversarial network with multiple generators provides a solution to the above problems by generating different fake samples from the real data distribution. The typical architecture of MAD-GAN is as Figure 3 shown, including k generators and one discriminator. Different from the traditional GAN, the output of the discriminator is modified to output k + 1 softmax scores. Specifically, given k generators, the discriminator must learn to distinguish between k types of generated samples and 1 type of real sample. When the model parameters of the discriminator D k+1 remain unchanged, the optimization objective function of the j-th generator can be expressed as:

[0046]

[0047] Since the discriminator D k+1 needs to measure the differences between k types of generated samples, the loss function of the discriminator D k+1 is modified to the multi-class cross-entropy loss function as follows:

[0048]

[0049] where H(·) is the negative value of the cross-entropy function. And δ ∈ {0, 1} k+1 is the Dirac distribution. Since MAD-GAN supports generating more diverse samples, it effectively reduces the possibility of mode collapse.

[0050] The main concept of the present invention will be briefly described below in combination with the problems existing in the prior art.

[0051] Non-IID data in FL can lead to local bias, resulting in lower convergence and higher precision loss. To improve the performance of non-IID data, existing research often uses GANs to synthesize samples to mitigate local bias, thereby reducing the impact of non-IID in FL. Specifically, the global data distribution can be obtained by collecting locally generated GAN data and local GAN model parameters, thus alleviating the non-IID problem. Cao et al. proposed a FL method based on collaborative training of GANs, which allows each client to train a local GAN network, and the server reduces the impact of non-IID by aggregating the locally generated GAN data. Li et al. proposed a new framework called Synthetic Data-Assisted FL (SDA-FL), where each client generates different private synthetic data and uploads it to the server to construct a globally shared synthetic dataset to address the challenges of non-IID. To further mitigate the non-IID problem, subsequent researchers alleviated the problem by transmitting local GAN model parameters. Hardy et al. proposed FL-GAN, aiming to train a group of GAN models using federated averaging. Specifically, each client has a common GAN model, and the global GAN model is obtained by aggregating local model updates. Jeong et al. proposed FAug, where each client jointly trains a GAN model by sharing model parameters and uses the GAN to augment its local data to alleviate the non-IID problem. Although the above solutions all use GAN models to synthesize data to alleviate the non-IID problem, they do not consider the mode collapse problem of the generator network during GAN training, which may lead to samples generated by the generator being too similar or lacking diversity, thus reducing the generalization ability and stability of the federated learning model. To prevent the mode collapse problem of GANs, Xin et al. proposed that FL-GAN uses a serial training method to maximize the use of data from each database, thereby training a high-quality model. Ma et al. proposed an unbiased FL scheme based on GANs, sharing samples generated by the generator among clients to prevent mode collapse while reducing local bias. However, the above solutions do not fully consider that the communication overhead of FL itself is not very suitable for multi-party data collaboration scenarios in industrial settings. Therefore, the present invention proposes training a Multi-Agent Adversarial Generative Network (MAD-GAN) with multiple generators and one discriminator to ensure the diversity of sample generation. When designing the loss function, a regularization term is added, see formula (6) in the previous text. The cosine distance is used in the regularization term to penalize the consistency of samples generated by different generators, prevent model collapse, thereby alleviating the non-IID problem, and addressing the communication overhead of FL when training a global model with multi-party data collaboration.

[0052] In the process of federated learning, Federated Averaging (FedAvg) is the most commonly used communication efficiency optimization method in federated learning. After multiple local iterations, this method uploads the model data for averaging, then updates it and distributes it locally. This strategy significantly reduces the number of communication rounds, thus effectively reducing the overall communication overhead of federated learning. Yang et al. proposed a novel federated averaging algorithm. When calculating the global model, this algorithm performs weighted averaging on the respective models according to the characteristics of different devices, thereby achieving more accurate model aggregation and further reducing the communication overhead. However, the problem of excessive communication cost in federated learning remains severe. To further solve this key problem, combining model compression technology is an effective way to improve the communication efficiency of federated learning. Some sparsification techniques are used to simplify the local gradients, including Top-k sparsification and Rand-k sparsification. By only transmitting k model parameters to form a sparse model, the number of model parameters can be compressed in this way. The present invention believes that Top-k sparsification is more suitable for practical applications. This is because compared with Rand-k, Top-k retains more useful model information, thus ensuring the performance of the model. However, there are still a large number of redundant parameters in transmitting the Top-k full-precision model. Sattler et al. have proven that this method will consume too much communication resources. Quantization can be used to eliminate redundant parameters. The FedPAQ scheme proposed by Reisizadeh et al. combines periodic averaging and quantization to reduce the amount of communication per time on the basis of reducing the total number of communication rounds. Konecny et al. compressed the model data through quantization, random rotation, and subsampling, effectively reducing the communication burden between the central server and the clients. Compared with the existing FL research, the present invention proposes a new data collaboration scheme applicable to industrial scenarios, comprehensively considering the non-IID of data and communication efficiency issues when applying FL, providing new ideas and methods for solving the current research gap.

[0053] The following specifically describes the solution of the present invention.

[0054] In a first aspect, an embodiment of the present invention provides a heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis, which is applied to a federated learning system composed of a server and multiple clients. Each client is provided with a local MAD-GAN model and a federated learning model; this heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis is called the SQC-FLMGAN framework (method). As Figure 4 shown, this method may include the following steps:

[0055] S1, each client downloads and initializes the weights of the local MAD-GAN model and the weights of the federated learning model from the server;

[0056] It is understandable that the initial values of the MAD-GAN model weights and the federated learning model weights are pre-stored in the server. When all clients start the first round of training of the federated learning model, they all download the above initial values from the server. For the i-th client, the initial value of the local MAD-GAN model weights can be expressed as which are respectively the initial values of the weights of its discriminator and generator; the initial value of the local federated learning model weights can be expressed as W i 0 ; Then the client configures the local MAD-GAN model and the federated learning model accordingly to obtain the locally available MAD-GAN model and the federated learning model.

[0057] S2. In the current round of training, each client uses its private data to train the local MAD-GAN model multiple times through a two-stage training method of local local training and server global aggregation until the trained federated MAD-GAN model is obtained;

[0058] Among them, the private data of each client contains multiple samples, and each sample is a bearing vibration signal with a label, and the label includes a normal state or a fault type. In the embodiment of the present invention, the federated learning model aims to identify the health state of the bearing, that is, to judge whether the bearing belongs to the normal state or a certain fault type, and the fault type can be set according to the actual situation. For example, in an optional embodiment, the fault type includes: inner ring fault, ball fault, outer ring fault.

[0059] The present invention constructs a MAD-GAN under the FL architecture to generate unbiased IID (Independent and Identically Distributed) data to address the Non-IID data distribution problem. The present invention designs a divide-and-conquer strategy. This strategy divides the training process of the MAD-GAN into two stages under the framework of the federated model: local training and global aggregation, which are respectively carried out on the client side locally and on the server.

[0060] Specifically, S2 may include the following steps:

[0061] S21. In the current round of training, each client uses its private data to perform the local local training of the current MAD-GAN model to obtain the local model parameters of the current local MAD-GAN model, including the generator weights and the discriminator weights;

[0062] Specifically, S21 includes the following steps:

[0063] S21-1. In the current t-th round of training, client U i samples real samples from the private data Sample a mini-batch of noise from the prior noise distribution p z as the seed vector seed = {z1, …, z K}, and pass each sub-seed in the seed vector to K generators; where i ∈ [1, N], and N is the total number of clients;

[0064] Among them, the labels of the real samples are known. The prior noise distribution p z is pre-set. The seed vector seed = {z1, …, z K} contains K seeds, i.e., noise. Input these K seeds into a generator. At the same time, the generator also receives the real sample

[0065] S21-2, and obtain the generated samples output by the K generators

[0066] According to the principle of the MAD-GAN model, the K generators will each output a generated sample. denotes the generated sample output by the j-th generator.

[0067] S21-3, feedback the generated samples output by the K generators and the real sample to the discriminator;

[0068] S21-4, use the discriminator to distinguish the types of the K generated samples and the real sample type;

[0069] The processing procedures of S21-3 to S21-4 can be understood by referring to the principle of the MAD-GAN model and will not be elaborated here. The type refers to the normal state or specific fault types.

[0070] S21-5, according to the types of the K generated samples and the real sample obtained by the discriminator, and the objective function of the MAD-GAN model, update the discriminator weights and the generator weights as the local model parameters of the MAD-GAN model for the current local iteration.

[0071] For the objective function of the MAD-GAN model, please refer to formula (5) in the previous text. The discriminator distinguishes the types of the K generated samples and 1 real sample, and then updates the discriminator weights to maximize the objective function V(D, G), and updates the generator weights To minimize the objective function V(D, G). The optimal MAD-GAN after this training is obtained through the adversarial training between the generator and the discriminator.

[0072] S22, each client uploads the local model parameters of the current local MAD-GAN model to the server;

[0073] Each client uploads the local model parameters of the current local MAD-GAN model, namely the obtained discriminator weights and generator weights, to the server.

[0074] S23, the server globally aggregates the local model parameters uploaded by all clients in the current round, obtains the current round of federated MAD-GAN model parameters, and distributes them to all clients for a new round of two-stage training. After the number of training rounds reaches the preset number of training rounds, the trained federated MAD-GAN model is obtained.

[0075] The server globally aggregates the local model parameters uploaded by all clients in the current round according to the FL framework, obtains the current round of federated MAD-GAN model parameters, and distributes them to all clients, which contain the aggregated discriminator weights and generator weights. At this time, one round of two-stage MAD-GAN model training is completed.

[0076] After that, each client reconfigures the local MAD-GAN model with the obtained federated MAD-GAN model parameters, and then executes S21 - S23 again. In the t-th round of training, a new round of two-stage MAD-GAN model training is completed and repeated continuously until the number of training rounds of the two-stage MAD-GAN model reaches the preset number of training rounds. In the t-th round of training, the trained federated MAD-GAN model is obtained, and the server distributes the federated MAD-GAN model parameters to the clients again.

[0077] S3, each client uses the obtained federated MAD-GAN model to generate sample-balanced Non-IID data, thereby realizing the expansion of private data; among them, each client uses the obtained federated MAD-GAN model to generate sample-balanced Non-IID data, including:

[0078] According to all types of labels in the private data of all clients, each client uses the obtained federated MAD-GAN model with the local private data as the input data to generate sample-balanced Non-IID data, thereby realizing the expansion of the label types of private data.

[0079] The purpose of this step is to make the types of labels in the private data of each client as comprehensive as possible and align with all label types. For example, in the private data of client A, the labels of the samples include the normal state, as well as two fault types: inner ring fault and ball fault. However, there are no samples of outer ring fault. Then, using the obtained federated MAD-GAN model, samples of outer ring fault can be generated for it as sample-balanced Non-IID data, so as to make the label types of the private data of client A more comprehensive.

[0080] S4. Each client uses the augmented private data and the weights of the federated learning model obtained in the current round to train the local federated learning model, and obtains the local updated model parameters of the local federated learning model in the current round of training.

[0081] After each client augments its local private data, since the local federated learning model has been reconfigured according to the weights of the federated learning model obtained in the current round, at this time, use the augmented private data to train the local federated learning model. For the specific training process, please refer to the related technology for understanding and will not be elaborated here.

[0082] After the training is completed, in the current round of training, the local updated model parameters of the local federated learning model are obtained. For client U i , the local updated model parameters of the local federated learning model can be denoted as It can be understood that the local updated model parameters of the local federated learning model contain multiple parameters of the federated learning model.

[0083] The present invention innovatively combines the MAD-GAN and the federated learning architecture, and divides the training stage of the MAD-GAN model into two stages: local training and global aggregation. In the local MAD-GAN training stage, each client uses the combination of its local private data and random noise as the input of the generator. This combination method ensures that the generator can learn the distribution characteristics of the local private data, and at the same time introduces randomness to increase the diversity of the generated samples. Algorithm 1 details the training process of the MAD-GAN model, including the alternating optimization steps of the generator and the discriminator. In this stage, each client does not directly transmit its local training data, but shares the parameters of the locally trained MAD-GAN model. Therefore, the privacy of the data is also protected during the MAD-GAN training process. After multiple communications and global aggregations, each client can use the final federated MAD-GAN model to generate supplementary data locally, thereby enriching its dataset and improving the generalization ability of the model.

[0084]

[0085]

[0086] In Algorithm 1, T represents the preset number of training times; represents the j-th generator in the local MAD-GAN model of client U in the t-th training; i of the local MAD-GAN model of client U in the t-th training; represents the discriminator of client U in the t-th training; same as D i ; K+1 ; represents the weight of the j-th generator in the local MAD-GAN model of client U in the t-th training; η represents the local learning rate. i of the local MAD-GAN model of client U in the t-th training; η represents the local learning rate.

[0087] In the MAD-GAN model of the embodiments of the present invention, the structures of the generator and the discriminator can be set as needed. In an optional embodiment, to adapt to the characteristics of one-dimensional bearing fault vibration data, in the local MAD-GAN model of each client, both the generator and the discriminator adopt a 5-layer deep neural network structure; this structure can fully extract data features while maintaining the model complexity. And in the intermediate layers of the generator and the discriminator, tanh and sigmoid are respectively used as activation functions, which can introduce non-linear factors and enhance the expression ability of the model. In the last layers of the generator and the discriminator, tanh and softmax are respectively used as activation functions. Tanh is used to limit the output of the generator within a specific range, while softmax is used to convert the output of the discriminator into a probability distribution for facilitating multi-classification tasks. Through the above strategy, high-quality IID data can be generated by MAD-GAN under the federated learning framework while protecting data privacy, so as to effectively address the challenges brought by non-IID data distribution.

[0088] S5. Each client locally updates the model parameters of the local federated learning model in the current round of training, compresses them using sparsification and quantization methods, and sends the compressed model parameters to the server;

[0089] The present invention provides an integrated compression scheme, aiming to achieve compression of the communication downlink through an optimized sparsification method and eliminate communication redundancy by combining quantization technology, thereby reducing communication overhead.

[0090] S5 specifically includes:

[0091] 1), Each client locally updates the model parameters of the local federated learning model in the current round of training, processes them using the sparsification method, and retains some key model parameters in the locally updated model parameters;

[0092] In an alternative implementation, the sparsification method is implemented using the Top-k algorithm.

[0093] The optimized Top-k sparsification algorithm minimizes communication overhead by transmitting key model parameters while ensuring the performance of the model. To prevent information loss and degradation of model performance, the sparse parameters will be accumulated during subsequent training to participate in subsequent sparse calculations. The specific form of the sparse operation is shown in the following formula:

[0094]

[0095] where p% of the elements are set to zero and the remaining elements remain unchanged. represents the parameter update value of client n, that is, the local updated model parameters of the local federated learning model. represents the sparse parameter value. is the cumulative residual gradient value initially set to zero.

[0096] However, the sparse strategy is effective in the uplink communication but has problems when applied in the downlink communication, mainly due to the heterogeneity of the client data distribution and features. Specifically, the client only retains the important parameters in the updated model, thereby achieving sparsity of the model parameters and further achieving sparsity of the uplink update.

[0097] The present invention adopts a generalized filtering mask to implement the sparsification process. In the Top-k sparsification process, the filtering mask M used matches the dimension of the model parameters and is used to filter and retain the top k key parameters in the model. The positions with a value of 1 in the mask correspond to the parameters to be retained, while the positions with a value of 0 correspond to the parameters to be set to zero. For the parameters marked as 0, the sparsification process is achieved by element-wise multiplication of the mask and the model parameters. Finally, only the parameters corresponding to the positions with a value of 1 in the filtering mask are retained in the model parameters, and the remaining positions will be set to zero, thus completing the sparsification. This part can be understood in combination with the Top-k algorithm.

[0098] The overall process of sparsification using the Top-k algorithm in the embodiments of the present invention is shown in Algorithm 2.

[0099]

[0100] In Algorithm 2, w t is a flattened tensor; p is the compression ratio; is a sparse tensor; n represents the client number; np represents the product of n and p; k is the key parameter k in Top-k; mask represents the mask; N represents the total number of clients; μ represents the process parameter. For details, please understand in combination with the existing Top-k algorithm.

[0101] To verify the impact of the sparse strategy of the present invention on model performance, experiments were conducted at different sparsity rates. Figure 5 It shows the performance of the average test accuracy of 10 clients after 200 rounds of iteration on the STU dataset at different sparsity rates. In the case of non-independent and identically distributed (Non-IID-Class) data distribution, when the same sparsity rate is used for both uplink and downlink, the test accuracy decreases by at most 1.5% compared to only performing uplink compression. In the non-independent and identically distributed (Non-IID-Random) case, the test accuracy decreases by at most 2.5%. Therefore, the impact of sparsification on model performance is relatively small.

[0102] 2), Quantize some of the remaining key model parameters to obtain the compressed model parameters, and send the compressed model parameters to the server.

[0103] To further improve communication efficiency, the present invention introduces quantization technology. Traditional Top-k sparse algorithms transmit the exact values of a certain proportion of model parameters during communication. However, by combining sparsification with the quantization technology of model parameters, more efficient compression can be achieved. During the sparse update process, the remaining Top-k elements are quantized by averaging their overall size. This quantization method significantly reduces the amount of data sent and stored, thus optimizing the entropy update algorithm. Compared with simple sparsification methods, the quantization technology can achieve a compression ratio of about 3 times. Figure 6 It shows the model compression process of the present invention. First, apply the Top-k algorithm to the sparse model parameters and only transmit some parameters. Then, adopt quantization technology to eliminate redundant parameters and further reduce communication overhead. Update weight represents updating the weight; Sparsify represents sparsification; binarize represents binarization; Sparse error represents sparse error.

[0104] S6, The server updates the weights of the federated learning model according to the compressed model parameters uploaded by all clients in the current round of training, and distributes them to each client;

[0105] S6 specifically includes:

[0106] 1), The server updates the weights of the federated learning model according to the compressed model parameters uploaded by all clients in the current round of training;

[0107] In this step, the server aggregates the compressed model parameters uploaded by all clients in the current round of training, such as weighted averaging, etc., to update the weights of the federated learning model. The process of this aggregation can be understood with reference to related technologies and will not be described here.

[0108] 2), compress the updated weights of the federated learning model using a sparsification method and send them to the server.

[0109] As the number of clients increases, the number of non-zero parameters used to aggregate each client in the federated learning model updated by the server gradually accumulates, resulting in the global updated model gradually losing sparsity and becoming dense. Therefore, the present invention proposes to apply the same sparsity rule as the uplink communication on the server side to compress the downlink communication, as shown in Equation 9.

[0110]

[0111] Through quantization processing, the present invention can eliminate redundant parameters and further reduce the amount of data transmitted.

[0112] S7, according to the weights of the federated learning model newly issued by the server, execute S4 - S6 again until the number of training rounds reaches the maximum number of rounds, and obtain a globally trained federated learning model for fault detection of the vibration signal of the bearing to be tested.

[0113] Through multiple rounds of communication, the present invention can obtain a high-performance FL global model.

[0114] As can be seen from the foregoing description, in order to improve the effect of federated learning in the field of faults, the present invention proposes an SQC-FLMGAN framework. For the principle, please refer to Figure 7 As shown, first, on the premise of ensuring the federated architecture and ensuring user privacy, a federated MAD-GAN is constructed to generate diverse data, supplement samples for users, alleviate the local data Non-IID problem, solve the mode collapse problem, and improve the diagnostic performance of the model. At the same time, in order to alleviate the problem of large communication overhead in the aggregation process, a new compression framework is proposed, which uses sparsification combined with quantization to compress the local updated model parameters to ensure the performance of the federated learning model and reduce the communication overhead.

[0115] The specific structure of SQC-FLMGAN is as described in Algorithm 3, including initialization, MAD-GAN training, and model compression.

[0116]

[0117]

[0118] In Algorithm 3, W represents the initial weights of the federated learning model; N represents the total number of clients; T represents the total number of rounds of training of the federated learning model; η represents the local learning rate; τ represents the number of local iterations, that is, the total number of times of MAD-GAN training within each round; p represents the sparsity rate; w represents the weights of the globally trained federated learning model. represents the local gradient of the i-th client during the k-th MAD-GAN training in the t-th round of training. It should be emphasized that k in Algorithm 3 represents the number of MAD-GAN training times and is a variable that has nothing to do with the previous TOP-k algorithm.

[0119] In summary, intelligent data-driven mechanical fault diagnosis methods have been widely developed. While they have achieved good diagnostic performance, existing methods typically require large amounts of high-quality supervised data for training, which is often difficult and expensive to collect in real-world industries. Federated learning has emerged as a promising approach to leveraging distributed data from multiple clients while preserving privacy. However, the diversity of devices and uneven load distribution in industrial environments result in data between devices being non-independent and identically distributed. Using this data for federated learning training can lead to decreased model performance and increased communication overhead, posing a key challenge that needs to be addressed.

[0120] In view of the above problems, an embodiment of the present invention provides an efficient federated learning method for heterogeneous data for intelligent manufacturing fault diagnosis (i.e., the SQC-FLMGAN architecture), which performs two-stage federated learning; the first stage is to train the MAD-GAN model in a federated learning environment, and obtain a trained federated MAD-GAN model through multiple interactions of local training and server global aggregation; the second stage is to use the federated MAD-GAN model to generate data samples with high diversity and quality for each client, and then train the federated learning model through local and server interactions to obtain a trained global federated learning model for fault detection of the vibration signal of the bearing to be tested.

[0121] Specifically, first, under the premise of ensuring data privacy, the method trains a federated multi-agent generative adversarial network (MAD-GAN) model. Multiple generators create diverse and high-quality data samples for each client, effectively solving the mode collapse problem and significantly improving the diagnostic performance of the model. However, the non-independent and identically distributed (Non-IID) characteristics of the data often lead to a decline in the convergence of model training, increasing the number of communication rounds and communication overhead required to achieve the same performance, which may affect the efficiency and practicality of FL. Therefore, the present invention also introduces a new compression framework to reduce the communication overhead during the second-stage data collaboration process. Sparsification techniques such as Top-k are used to transmit significantly updated model parameters using the update size as a heuristic to ensure model performance and minimize communication costs. To further improve communication efficiency and eliminate redundant parameters in communication, the remaining model parameters in the sparse update are quantized to the average overall size. This method not only optimizes the communication efficiency between the client and the server but also maximally retains the model performance, achieving a significant compression effect while reducing communication costs. The beneficial effects of the present invention can be summarized as follows:

[0122] 1) A multi-party data collaboration scheme SQC-FLMGAN in industrial scenarios is proposed, effectively alleviating the problems of model performance degradation and high communication overhead caused by multi-party non-IID data.

[0123] 2) A joint data augmentation scheme based on FL and MAD-GAN is proposed, and it is analyzed from theoretical and experimental results that this scheme can effectively improve model performance.

[0124] 3) A model compression scheme is adopted in the aggregation step of the FL fault diagnosis model to reduce communication costs. Specifically, sparsification is used to compress model parameters and quantization is used to eliminate redundant parameters, achieving better compression gain while ensuring model performance.

[0125] 4) Extensive experiments are conducted on the industrial equipment fault dataset. The results show that the method of the present invention is effective in reducing the impact of Non-IID, and is superior to the existing FL frameworks in terms of model accuracy and communication overhead compared with existing methods.

[0126] To verify the effectiveness of the method of the present invention, the following provides relevant experimental descriptions.

[0127] In the experiment, the public bearing dataset of Case Western Reserve University in the industrial field and the bearing dataset self-constructed by Shandong University of Science and Technology were used to verify the proposed SQC-FLMGAN method. Each client holds two components, including the MAD-GAN and the FL model. For the MAD-GAN model, DNN is used as the basic structure of the generator and the discriminator. The generator and the discriminator have a three-hidden-layer structure, and tanh and sigmoid are selected as the activation functions respectively. The federated MAD-GAN is trained for 150 communication rounds, where each local MAD-GAN is trained for 10 epochs using the adam optimizer with a learning rate of 1×10-6 and a batch size of 32. The CNN is used as the FL model, which has three hidden convolutional layers with ReLU as the activation function and includes batch normalization layers and max pooling layers. After passing through the convolutional, batch normalization, max pooling, and fully connected layers in the input layer, the last layer outputs a feature vector with 10 dimensions. The local FL model is trained using the SGD optimizer, and the learning rate and momentum term are 0.01 and 0.9 respectively.

[0128] Table 1 shows the health conditions included in the two datasets: normal condition and three types of faults (rollers, inner rings, and outer rings), as well as different damage degrees of each fault.

[0129] In Experiment 1, the dataset of Case Western Reserve University was used to verify the proposed method, as Figure 8 shown. The bearing test platform consists of: 1) a motor, 2) an accelerometer, 3) a torque sensor, and 4) a dynamometer. An acceleration sensor was installed on the SKF6205 drive-end bearing to record vibration signals at a sampling rate of 12 kHz. This dataset is divided into four working condition data with rotational speeds of 1797, 1772, 1750, and 1730 r / min respectively. In the experiment, taking the rotational speed of 1797 as an example, it is divided into inner ring faults, ball faults, and outer ring faults, with defect sizes of 0.1778, 0.3556, and 0.5334 mm respectively. 3000 samples were collected for this dataset to form a dataset, and each sample has 400 vibration points. In the experiment, 1500 samples were distributed to the clients in a Non-IID form, and 1500 samples were used as the test set on the server side.

[0130] In Experiment 2, the STU dataset consists of vibration signals collected by a bearing failure implantation test bench, as Figure 9As shown in the figure. It consists of: 1) Motor, 2) Shaft coupling, 3) Rotor, 4) Bearing set, 5) Vibration sensor, 6) Acoustic sensor, 7) Brake. An acceleration sensor is installed on the SKF6205 drive-end bearing to record vibration signals at a sampling rate of 25.6 kHz. This dataset is divided into three operating condition data with rotational speeds of 1500, 1800, and 2000 r / min respectively. In the experiment, taking the rotational speed of 1500 as an example, it is divided into inner race fault (IF), ball fault (BF), and outer race fault (OF), and the defect sizes are 0.2, 0.4, and 0.6 mm respectively. For this dataset, 4000 samples are collected to form the dataset, and each sample has 1280 vibration points. In the experiment, 2000 samples are distributed to the clients in a Non-IID form, and 2000 samples are used as the test set on the server side. Among them, N / A(H) represents the healthy state.

[0131] Table 1. Descriptions of the self-generated bearing dataset and the Case Western Reserve University motor bearing dataset

[0132]

[0133] In view of the fact that fault data often exhibits Non-IID characteristics in practical applications, the present invention focuses on the results of fault data under Non-IID conditions. Based on existing methods, the present invention considers two different data distribution scenarios.

[0134] (1) Non-IID-Class

[0135] In this strategy, the amount of data for each category remains the same, but the data category distributions are different. This simulates the situation in practical applications where although the collection amounts of different category fault data are quite the same, due to the differences in their inherent characteristics, the data category distributions are uneven. This strategy helps the present invention evaluate the performance of the proposed method when facing the differences in data category distributions.

[0136] (2) Non-IID-Random

[0137] This is a more practical Non-IID situation. Among them, not only the data distributions of different categories are different for different clients, but also the amounts of data are significantly different. This is closer to the actual scenario where the distribution and quantity of fault data are affected by various factors, such as the rarity of fault types, the difficulty of data collection, etc. This scenario simulates extremely deviated local data in extreme cases and is more suitable for evaluating the performance of the model in actual industrial situations. Specific categories are as Figure 10 shown.

[0138] In the experiment, different learning methods were considered to verify the algorithm superiority of this method.

[0139] 1) FedAvg: An algorithm widely used in federated learning. It is used to train local models locally multiple times on multiple clients, and then aggregate the model parameters of each model through an averaging operation. After multiple rounds of communication, an optimized global model is obtained.

[0140] 2) FedProx: An optimization algorithm in federated learning. It aims to limit the distance between the client model update and the global model through a proximal term, which is used to alleviate the Non-IID problem of data in federated learning.

[0141] 3) FedGAN: Train an optimized global GAN model in the way of FL. Each client uses the GAN model to synthesize local data to supplement local missing data samples and alleviate the Non-IID problem.

[0142] 4) FLMGAN: The federated MAD-GAN model trained by the distributed strategy proposed in the present invention. Each client uses the MAD-GAN model to generate diverse data locally, preventing mode collapse and alleviating the Non-IID problem at the same time.

[0143] 5) SQC-FLMGAN: Based on FLMGAN and combined with the compression scheme proposed in the present invention, the model parameters are compressed by sparsity and quantization to reduce communication overhead.

[0144] Analysis of experimental results:

[0145] 1) Evaluation of the quality of generated data

[0146] To evaluate the quality of the federated MAD-GAN model, the real data was compared and analyzed with the federated MAD-GAN synthesized data. The results are as Figure 11 shown in the comparison of the frequency characteristics of the real data (blue) and the generated data (red). In the frequency domain graph, the horizontal axis and the vertical axis represent frequency and amplitude respectively. It can be clearly seen from Figure 11 that the generated data is very similar to the real data. This indicates that the federated MAD-GAN model proposed in the present invention has successfully captured the distribution information of the real data.

[0147] In subsequent experiments, to mitigate the impact of Non-IID data on federated learning, Federated MAD-GAN was adopted to synthesize data for FL clients. For the CWRU dataset and the STU dataset, 1500 and 2000 samples were distributed to clients in a Non-IID manner respectively. Ideally, each client has half of the class data, with the data volumes being 30 and 40 respectively. To construct an IID data distribution, for the CWRU dataset, each class of data for the clients was supplemented to 30 samples. Similarly, in the STU dataset, each class of data for the clients was supplemented to 40 samples. This strategy synthesizes data using Federated MAD-GAN, supplements samples of missing classes, improves data diversity, and thus alleviates the impact of Non-IID data on the performance of federated learning.

[0148] 2) Influence of the number of generators

[0149] The present invention proposes a method using federated learning (FL) to train a MAD-GAN model, aiming to supplement missing fault samples for each client to alleviate the sample Non-IID problem. However, due to the unique architecture of the MAD-GAN model, determining the appropriate number of generators becomes a key issue. The present invention observes the influence of the number of generators on the model output results by gradually adjusting the number of generators. To ensure the effectiveness of the experiment, a series of strict experimental settings were adopted. First, in the case where the client data distribution is Non-IID-Random, the MAD-GAN model was initially trained using the FL method. Then, the MAD-GAN model was used to generate IID data samples for each client, converting the local Non-IID data into IID data. Subsequently, each client jointly trained an FL diagnostic network.

[0150] In Table 2, the results of multiple experiments with different numbers of generators are detailed. These data clearly show that the number of generators has a significant impact on the accuracy of the diagnostic method. In particular, when the number of generators is set to 3, the diagnostic accuracy reaches the highest level. Based on this finding, in subsequent comparative experiments, it was decided to fix the use of 3 generators in the MAD-GAN model.

[0151] Table 2 Test accuracy of different numbers of generators on the CWRU dataset

[0152]

[0153]

[0154] Table 3 Test accuracy of each method under different data distributions

[0155]

[0156] 3) Communication Overhead Analysis

[0157] In terms of communication overhead, FLMGAN has accelerated model convergence and reduced communication overhead through data augmentation. On this basis, SQC-FLMGAN further improves communication efficiency by compressing the model size. For example, for the STU dataset, when achieving 88% accuracy on the target test, the communication volume of FLMGAN is 17.28MB. In contrast, FedAvg requires 88.69MB of communication volume, and the communication volume is reduced by 5.13 times. This shows that data augmentation can reduce the number of communication rounds required for convergence and lower communication overhead. SQC-FLMGAN compresses the model size with a sparsity rate of 0.1, further reducing communication overhead. To further demonstrate the communication efficiency of the method of the present invention, the relationships between test accuracy and communication rounds and the communication overhead of different comparison methods are respectively shown in Figure 12 . It can be seen from Figure 12 that the method of the present invention can achieve higher test accuracy under the same communication overhead. For example, SQC-FLMGAN in the STU dataset has converged with a communication volume of approximately 3MB, while FedAvg requires approximately 100MB of communication volume to converge better, indicating that the method of the present invention significantly reduces communication overhead.

[0158] In summary, to solve the non-independent and identically distributed (non-IID) data problem in fault diagnosis for industrial Internet of Things (IIoT) systems, the present invention generates diverse and high-quality data samples by training a multi-agent generative adversarial network (MAD-GAN), effectively alleviates the mode collapse problem, and significantly improves the diagnostic performance of the model. At the same time, a novel compression framework is introduced, combining Top-k sparsification and quantization techniques to reduce the communication overhead of model parameter transmission while maintaining model performance. To verify the effectiveness of SQC-FLMGAN, extensive experiments are conducted using datasets in industrial scenarios. The experimental results show that the method of the present invention has achieved significant results in both model accuracy and communication efficiency.

[0159] In a second aspect, corresponding to the above method embodiment, an embodiment of the present invention further provides a federated learning system, including a server and multiple clients, and each client is provided with a local MAD-GAN model and a federated learning model; the federated learning system uses the heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis described in the first aspect to obtain a trained global federated learning model for fault detection of the vibration signal of the bearing to be measured.

[0160] For the specific processing process of this federated learning system, please refer to the relevant content of the first aspect and will not be elaborated here.

[0161] This solution is based on the Multi-Agent Generative Adversarial Network (MAD-GAN) framework. By training the MAD-GAN model in a federated learning environment, highly diverse and high-quality data samples are generated for each client. This process effectively alleviates the mode collapse problem and improves the generalization ability and diagnostic accuracy of the model. To further reduce the communication overhead, an advanced model compression technology is introduced, which combines Top-k sparsification and quantization methods. The Top-k algorithm selects the most important model parameters for transmission, and the quantization technology further reduces the representation precision of these parameters, thus eliminating redundancy in the communication process and reducing the amount of data transmission. The practical application of this solution in industrial scenarios demonstrates the potential to reduce operating costs, improve diagnostic accuracy, and reduce the risk of unexpected downtime, providing strong technical support for the further development of intelligent manufacturing and industrial automation.

[0162] The above are only the preferred embodiments of the present invention and are not intended to limit the protection scope of the present invention. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principle of the present invention are included in the protection scope of the present invention.

Claims

1. An efficient federated learning method for heterogeneous data in intelligent manufacturing fault diagnosis, characterized in that, Applied to a federated learning system consisting of one server and multiple clients, each client is set with a local MAD-GAN model and a federated learning model; the method includes: S1, each client downloads and initializes the weights of the local MAD-GAN model and the weights of the federated learning model from the server; S2, in the current round of training, each client uses private data and, through a two-stage training method of local local training and server global aggregation, trains the local MAD-GAN model multiple times until a trained federated MAD-GAN model is obtained; wherein, the private data of each client includes multiple samples, each sample is a bearing vibration signal with a label, and the labels include normal state or fault type; S3, each client uses the obtained federated MAD-GAN model to generate sample-balanced Non-IID data, thereby realizing the expansion of private data; S4, each client uses the expanded private data and the weights of the federated learning model obtained in the current round to train the local federated learning model, and obtains the local updated model parameters of the local federated learning model in the current round of training; S5, each client compresses the local updated model parameters of the local federated learning model in the current round of training by using a sparsification method and a quantization method, and sends the compressed model parameters to the server; S6, the server updates the weights of the federated learning model according to the compressed model parameters uploaded by all clients in the current round of training, and distributes them to each client; S7, according to the newly distributed weights of the federated learning model by the server, execute S4-S6 again until the number of training rounds reaches the maximum number of rounds, and obtain a trained global federated learning model for fault detection of the to-be-tested bearing vibration signal.

2. The method according to claim 1, wherein In the current round of training, each client uses private data and, through a two-stage training method of local local training and server global aggregation, trains the local MAD-GAN model multiple times until a trained federated MAD-GAN model is obtained, including: In the current round of training, each client uses private data for local local training of the current MAD-GAN model, and obtains the local model parameters of the current local MAD-GAN model, including generator weights and discriminator weights; Each client uploads the local model parameters of the current local MAD-GAN model to the server; The server performs global aggregation processing on the local model parameters uploaded by all clients in the current time, obtains the current federated MAD-GAN model parameters, and distributes them to all clients for a new round of two-stage training until the number of training times reaches the preset number of training times, and a trained federated MAD-GAN model is obtained.

3. The method according to claim 2, wherein In the current round of training, each client uses private data for local local training of the current MAD-GAN model, and obtains the local model parameters of the current local MAD-GAN model, including: In the current t-th round of training, client U i Sample real samples from the private data Sample a mini-batch of noise from the prior noise distribution p z as the seed vector seed = {z1, …, z K}, and pass the various sub-vectors in the seed vector to K generators; where i ∈ [1, N], and N is the total number of clients; Generate samples obtained from the outputs of K generators j ∈ [1, K]; The generated samples output by K generators and the real samples are fed back to the discriminator; Use the discriminator to distinguish the types of the K generated samples and the real samples of the types; The types of the K generated samples obtained according to the discriminator and the types of the real samples and the objective function of the MAD-GAN model are used to update the discriminator weights and the generator weights as the local model parameters of the MAD-GAN model for the current local iteration.

4. The method according to claim 1, wherein Each client uses the obtained federated MAD-GAN model to generate sample-balanced Non-IID data, including: According to all types of tags in the private data of all clients, each client uses the local private data as input data and utilizes the obtained federated MAD-GAN model to generate sample-balanced Non-IID data, thereby realizing the expansion of the tag types of private data.

5. The method according to claim 1, characterized in that In each client's local federated learning model during the current round of training, the locally updated model parameters are compressed using sparsification and quantization methods, and the compressed model parameters are sent to the server, including: In each client's local federated learning model during the current round of training, the locally updated model parameters are processed using the sparsification method, and some key model parameters in the locally updated model parameters are retained; The retained partial key model parameters are quantized to obtain the compressed model parameters, and the compressed model parameters are sent to the server.

6. The method according to claim 1, characterized in that The server updates the weights of the federated learning model according to the compressed model parameters uploaded by all clients during the current round of training and distributes them to each client, including: The server updates the weights of the federated learning model according to the compressed model parameters uploaded by all clients during the current round of training; The updated weights of the federated learning model are compressed using the sparsification method and sent to the server.

7. The method according to claim 1 or 5 or 6, characterized in that The sparsification method is implemented using the Top-k algorithm.

8. The method according to claim 1, wherein In the local MAD-GAN model of each client, both the generator and the discriminator adopt a 5-layer deep neural network structure; and in the middle layer of the generator and the discriminator, tanh and sigmoid are respectively used as activation functions, and in the last layer of the generator and the discriminator, tanh and softmax are respectively used as activation functions.

9. The method according to claim 1, wherein The fault types include: inner race fault, ball fault, outer race fault.

10. A federated learning system, characterized in that, It includes a server and multiple clients, and each client is provided with a local MAD-GAN model and a federated learning model; the federated learning system uses the heterogeneous data efficient federated learning method for intelligent manufacturing fault diagnosis according to any one of claims 1-9 to obtain a trained global federated learning model for fault detection of the vibration signal of the bearing to be measured.

Images