A Data Augmentation Method for Multi-Layer Federation Generative Adversarial Networks

Abstract

This invention discloses a multi-layered, horizontally federated generative adversarial network (GAN) data augmentation method, belonging to the field of data augmentation technology. It generates high-quality image data and expands the training dataset through multi-client collaborative use of the GAN, while reducing local computational resource consumption, thus achieving data augmentation for downstream training tasks. Under a client-middle-layer server-top-layer server hierarchical architecture, a data augmentation method that balances image generation quality and training stability is constructed. This method reduces data transmission between clients and middle-layer servers through client-local training and a federated learning mechanism combining horizontal and vertical layers, enhances the detail consistency of generated data using perceptual loss, introduces gradient penalty to improve adversarial training stability, and balances the contributions of each client through dynamic weight allocation.

Description

Technical Field

[0001] This invention relates to the field of data augmentation technology, and more specifically, to a data augmentation method for multi-layered, cross-layered, federated generative adversarial networks. Background Technology

[0002] With the development of deep learning technology, GANs have become an important means of data augmentation and are widely used in fields such as medical imaging, autonomous driving, and financial risk control. However, in practical applications, data is often scattered across multiple clients, and due to privacy protection regulations (GDPR, HIPAA) and the problem of data silos, centralized training is not possible.

[0003] Therefore, the combination of federated learning and GAN has become a research hotspot. Existing solutions mainly include horizontal federated GAN (different samples for each client), centralized distributed training (central server aggregates), and edge computing GAN (independent training).

[0004] However, the existing solutions have several technical problems:

[0005] 1. Huge communication overhead:

[0006] Traditional federated GAN data augmentation schemes require frequent transmission of complete images, gradients, or parameters. High-resolution images can be transmitted in hundreds of MB at a time, which seriously affects training efficiency in edge network environments.

[0007] 2. Heavy computational burden on the client side:

[0008] Existing data augmentation solutions require clients to deploy both generators and discriminators for complete adversarial training, which is difficult for edge devices (mobile terminals, IoT devices) to handle due to their limited computing power and memory.

[0009] 3. Unstable training:

[0010] In federated learning scenarios, client data distribution is heterogeneous, and coupled with the inherent pattern collapse and gradient vanishing problems of GANs, the training failure rate is as high as 60% or more.

[0011] 4. Insufficient quality of generated data:

[0012] Relying solely on the adversarial signal from the discriminator results in weak or delayed feedback in federated learning scenarios, leading to blurred details and distorted textures in the generated images, making it difficult to meet the accuracy requirements of downstream tasks.

[0013] 5. Insufficient privacy protection:

[0014] Some solutions require uploading original images or intermediate activation values, which poses a risk of privacy breaches and cannot be applied to sensitive areas. Summary of the Invention

[0015] The purpose of this invention is to design and develop a multi-layered, cross-layered federated generative adversarial network (GAN) data augmentation method. This method achieves cross-layered federation through a three-layer system, combining adaptive weight allocation and a perceptual loss mechanism to reduce communication overhead and improve the quality of generated data and training stability.

[0016] The technical solution provided by this invention is as follows:

[0017] A method for data augmentation in multi-layered, cross-layered, federated generative adversarial networks includes the following steps:

[0018] Step 1: Collect the location and number of clients that need data augmentation. The location of the server equipment and the amount of data ;

[0019] Step 2: Determine the intermediate server;

[0020] Step 3: Select a top-level server from all mid-level servers using a clustering algorithm;

[0021] Step 4: Construct the first-layer vertical federation structure from the client to the middle-layer server and the second-layer horizontal federation structure from the middle-layer server to the top-layer server;

[0022] Step 5: Input random noise and the original dataset into the trained two-layer federated structure to obtain high-quality generated data;

[0023] Step 6: Combine the generated high-quality data set with the original data set to form the enhanced dataset.

[0024] Preferably, step two includes:

[0025] Based on the relative distance between the client and the server and the degree of data similarity between clients, determine which servers can serve as intermediate-level servers.

[0026] Preferably, step three specifically includes the following steps:

[0027] Step (a): Calculate the location center point between all mid-tier servers:

[0028] ;

[0029] In the formula, The location center point for all mid-tier servers, and , Represents the number of mid-tier servers;

[0030] Step (b): Select the middle-level server closest to the location center point as the top-level server.

[0031] ;

[0032] In the formula, The location of the top-level server. To make the function take the minimum value value.

[0033] Preferably, step four specifically includes the following steps:

[0034] Step 1: Build the self-model of all node devices:

[0035] All client, mid-level server, and top-level server models are GAN models, with the client consisting only of a generator and the top-level server consisting only of a discriminator.

[0036] Step 2: Initialize all node devices, load the required parameters, and prepare for data augmentation calculations;

[0037] The parameters include: the parameters of the generator in the client, the parameters of the generator and discriminator in the middle-layer server, the parameters of the discriminator in the top-layer server, the autoencoder parameters of the client, and the autoencoder parameters of the middle-layer server.

[0038] Step 3: Train the constructed two-layer federation structure until the required training rounds are reached.

[0039] Preferably, step 3 specifically includes the following steps:

[0040] Step 1) Train the generator in the client;

[0041] The input parameters of the generator in the client include: a random noise vector and the width of the overlapping image sub-regions; the output parameters are the overlapping images and their network parameters.

[0042] Step 2) The mid-level server dynamically allocates client parameter aggregation weights based on the generator's training loss in the client, for adversarial training of its own model;

[0043] The input parameters of the generator in the middle-layer server include: the overall network parameters after effectively concatenating the network parameters of the generators in multiple clients and a random noise vector; the output parameters are the generated new image data and its intermediate representation.

[0044] The input parameters of the discriminator in the intermediate server include: new image data generated by the generator in the intermediate server and the original data; the output parameter is the discrimination result of the image data.

[0045] Step 3) The top-level server trains a global discriminator based on the features transmitted by the middle-level servers;

[0046] The input parameters of the discriminator in the top-level server include: the intermediate representation of the new image data generated by the generator in each intermediate server, the discrimination result of the discriminator in each intermediate server on the image and the original data, and the output parameters are the global discrimination result and its network parameters.

[0047] Step 4) Each layer begins to send parameters to the next layer, updates the parameters of each node device, and continues training until the training round is reached.

[0048] Preferably, step 4) specifically includes:

[0049] The top-level server feeds back the global discrimination result and its discriminator's network parameters to the discriminator of the middle-level server. After updating, the discriminator of the middle-level server feeds back its discrimination result for the image data and the top-level server's discrimination result for the image to the generator of the middle-level server. The generator of the middle-level server then feeds back the network parameters belonging to the client and the obtained discrimination result to the generator of the corresponding client. The generator of the client optimizes its own training parameters based on the feedback result. After reaching the training rounds, the client generates high-quality data.

[0050] Preferably, the width of the overlapping image sub-region satisfies:

[0051] ;

[0052] In the formula, The width of the overlapping image sub-region. The original image width, The width of the overlapping region is represented by / / , which indicates truncation of decimal places for integer division.

[0053] Preferably, the training objective loss function of the client generator is:

[0054] ;

[0055] In the formula, For the first The total loss value of the generator for each client, For mathematical expectation, The random noise input to the generator, To start from the prior distribution Mid-sampling , For the first A generator network for each client based on noise The generated image, The data is real data collected from the client. To perceive loss.

[0056] Preferably, the generator output of the intermediate server satisfies:

[0057] ;

[0058] In the formula, New image data generated by the generator of the mid-level server. For the first A generator for a mid-tier server. For the first During the round of iteration, the first The intermediate representation of network parameters is obtained by effectively concatenating the generator network parameters of each client in the cluster of intermediate-level servers.

[0059] Preferably, the discriminator loss function of the intermediate server satisfies:

[0060] ;

[0061] In the formula, The loss value of the mid-level server discriminator. To determine the distribution of real data Expectations for random noise The output mapped to the data space, Discriminator for mid-level servers For generated samples The judgment output, Discriminator for mid-level servers For raw data The output, The representative parameter is of Distributed data .

[0062] The beneficial effects of this invention are as follows:

[0063] (1) The present invention designs and develops a multi-layer vertical and horizontal federation generative adversarial network data augmentation method, which realizes the adaptation of vertical and horizontal federation through a three-layer system. The client has limited resources but has data, the middle layer server undertakes aggregation training, the top layer server is responsible for global coordination, and different clients are responsible for different feature dimensions. The features are spliced ​​at the feature level, and auxiliary signals such as perceptual loss are introduced to provide a stable optimization direction. This can reduce communication overhead, reduce client computing load, reduce training failure rate, improve generation quality, and at the same time, the data does not leave the local machine, which meets privacy regulations. It provides a feasible data augmentation technology path for resource-constrained and privacy-sensitive scenarios such as edge computing and medical imaging.

[0064] (2) The multi-layer federated generative adversarial network data augmentation method designed and developed in this invention only deploys the generator on the client side, without the need for a discriminator. It uses perceptual loss for independent training and only uploads parameters at the end of the training cycle instead of uploading data or gradients in each batch, that is, it only performs local training on the client side; the middle layer server only transmits abstract features instead of complete images, which greatly reduces the amount of data, that is, the middle layer server only performs feature-level transmission; through the two-layer federated structure, feature splitting is adopted instead of data splitting, which naturally reduces the communication requirements, thereby significantly reducing the communication overhead and computational burden. Compared with traditional generative data augmentation methods, this method greatly reduces the amount of communication and client computation.

[0065] (3) The multi-layered vertical and horizontal federated generative adversarial network data augmentation method designed and developed in this invention directly constrains the structure and semantic consistency of the data through the perceptual loss mechanism, making up for the shortcomings of adversarial loss; it prevents gradient explosion and mode collapse through gradient penalty; and it improves the quality of generated data and training stability by dynamically allocating weights according to the client training loss and filtering low-quality contributions through dynamic weight aggregation.

[0066] (4) The present invention designs and develops a multi-layered vertical and horizontal federated generative adversarial network data augmentation method. The client trains only locally and only uploads model parameters; the server only receives high-dimensional abstract features and cannot reverse the original image, thus protecting data privacy. The client's original data does not leave the local area, which meets the needs of sensitive scenarios such as medical and financial fields.

[0067] (5) The multi-layered vertical and horizontal federated generative adversarial network data augmentation method designed and developed in this invention aggregates different data distributions through multi-client collaboration, and the global model learns a wider range of data patterns; through the quality weighting mechanism of the middle-layer server, it prevents the dominance of a single client and ensures diversity; the above advantages together constitute an efficient, safe and high-quality distributed data augmentation scheme, thereby improving the diversity of data augmentation, improving the performance of downstream tasks, and improving the data type coverage of the generated data. Attached Figure Description

[0068] Figure 1 This is a schematic diagram of a scenario for the multi-layered, horizontally and vertically federated generative adversarial network data enhancement method described in this invention.

[0069] Figure 2 This is a flowchart illustrating the multi-layered, cross-layered, federated generative adversarial network data augmentation method described in this invention. Detailed Implementation

[0070] The present invention will now be described in further detail with reference to the accompanying drawings, so that those skilled in the art can implement it based on the description.

[0071] This invention provides a multi-layered, cross-layered, federated generative adversarial network (GAN) data augmentation method, which, through methods such as... Figure 1 Implement the scenario shown, such as Figure 2 As shown, the specific steps include the following:

[0072] Step 1: Collect the location and number of clients that need data augmentation. The location of the server equipment and the amount of data ;

[0073] Step 2: Determine the intermediate server:

[0074] Based on the relative distance between the client and the server and the degree of data similarity between clients, determine which servers can serve as intermediate-level servers;

[0075] Among them, when the physical distance between the client and the candidate server is less than or equal to a preset distance threshold When this happens, the server is determined to be a neighboring server; the preset distance threshold The value range is from 10 km to 50 km, preferably 30 km; based on this, the data similarity between clients belonging to the same adjacent server is further calculated. If the cosine similarity between any two clients is greater than 0.98, their data distribution is considered to be sufficiently similar and suitable for collaborative data augmentation tasks under the same federated structure, and the adjacent server is identified as a mid-level server.

[0076] The distance formula is as follows:

[0077] (1)

[0078] In the formula, For the first The client and the first The distance between servers For the first The location of each client. For the first The location of each server;

[0079] Data similarity is calculated using cosine similarity, and the formula is:

[0080] (2)

[0081] In the formula, Indicates the number of clients. Indicates the first Data types in each client The percentage of the sample size For the first Data types in each client The percentage of the sample size

[0082] In this embodiment, the raw data used is the MNIST dataset, and the data type refers to the numeric ID, meaning there are 10 data types in total.

[0083] Step 3: Select a top-level server from all the mid-tier servers;

[0084] In this embodiment, the top-level server is determined by a clustering algorithm, specifically the K-means algorithm, which includes the following steps:

[0085] Step (a): Calculate the location center point between all mid-tier servers:

[0086] (3)

[0087] In the formula, The location center point for all mid-tier servers, and , Represents the number of mid-tier servers;

[0088] Step (b): Select the middle-level server closest to the location center point as the top-level server.

[0089] (4)

[0090] In the formula, The location of the top-level server. Represents the th radical that minimizes the value of the radical. One server.

[0091] Step 4: Construct the first-layer vertical federation structure from the client to the middle-tier server and the second-layer horizontal federation structure from the middle-tier server to the top-tier server, specifically including:

[0092] Step 1: Build the self-model of all node devices:

[0093] All nodes (clients, middle-level servers, and top-level servers) have their own models as GAN models, and the client only includes the generator, while the top-level server only includes the discriminator.

[0094] Step 2: Initialize all node devices, load the required parameters, and prepare for data augmentation calculations;

[0095] The parameters include: the parameters of the generator in the client, the parameters of the generator and discriminator in the middle-layer server, the parameters of the discriminator in the top-layer server, and the parameters of the autoencoder in the client and the middle-layer server.

[0096] The autoencoder is used to sense the loss of the image;

[0097] Step 3: Train the constructed two-layer federation structure until the required training rounds are reached;

[0098] The client uses the data it collects to train its own generator and uses loss perception to optimize the effect of data generation. Specifically:

[0099] Assuming the data to be supplemented is image-based, and each client's original dataset is a subset of the MNIST dataset, the number of clients in each vertical federated learning architecture is... = 2.

[0100] Step 1) Train the client generator:

[0101] The input parameters of the generator in the client include: a random noise vector sampled from the standard normal distribution N(0,1) and the width of the overlapping image sub-region. The output of the client is the data it generates (i.e., the generated overlapping image), but this data is not directly transmitted to the intermediate server. The intermediate server essentially accepts the parameters of the client (i.e., the network parameters of the client's generator). Multiple clients concatenate the parameters together to form the complete input parameters of the generator of the intermediate server.

[0102] In this federated learning framework, a vertical federated learning relationship is formed between the client and the mid-level server. This means each client trains only a portion of the data. However, during the final data concatenation, the data labels generated by each client may differ, rendering the concatenation meaningless. Therefore, an overlapping region is introduced. If the overlapping regions of the data generated by each client are the same or highly similar, it is safe to concatenate the data from each part together. Thus, in the federated learning framework described in this invention, the width of the overlapping image sub-region in the client's input parameters is calculated as follows:

[0103] (5)

[0104] In the formula, This represents the width of the overlapping image sub-regions processed by the client in the vertical federated learning structure. The original image width, The width of the overlapping region; / / represents truncation of decimal places for integer division.

[0105] During training, the target loss function for the client generator is:

[0106] (6)

[0107] In the formula, For the first The total loss value of the generator for each client, For mathematical expectation, The random noise input to the generator, To start from the prior distribution Mid-sampling , For the first A generator network for each client based on noise The generated image, The data is real data collected from the client. To perceive loss;

[0108] The formula for calculating the perceived loss is as follows:

[0109] (7)

[0110] In the formula, The first in the client generator network The weight coefficients of the layers are summed. The total number of network layers. Indicates that the data has passed the first time. Intermediate results after the layer, It is the square of the L2 norm.

[0111] Step 2) The intermediate server dynamically allocates client parameter aggregation weights based on the training loss of the client generator for adversarial training of its own GAN;

[0112] In the intermediate server, the generator first receives a random noise vector sampled from the standard normal distribution N(0,1) and the network parameters of the generator uploaded by the local client, and concatenates and aggregates them (since it is a vertical federated learning, parameter concatenation is required). Then, the generator is trained using the processed parameters.

[0113] The first The dynamic weights calculated for each client satisfy the following:

[0114] (9)

[0115] In the formula, This is a temperature hyperparameter used to control the weight differences between different clients;

[0116] In this embodiment, the temperature hyperparameter ranges from 0.1 to 1.0, where... It exhibits the best convergence performance on multiple datasets when the coefficient is 0.3;

[0117] Therefore, the parameter aggregation described by the middle-layer server satisfies:

[0118] (8)

[0119] In the formula, For the first A generator for a mid-tier server. For the first Dynamically calculated weights for each client. For the first During the round of iteration, the first The intermediate representation of the network parameters obtained by effectively concatenating the generator network parameters of each client in the cluster of intermediate-level servers (the obtained intermediate representation). For the first A collection of clients for a mid-level server;

[0120] Based on the parameter aggregation, the first During the round of iteration, the first The first in the cluster of mid-level servers The parameters uploaded by the generator on each client are used by the generator on the middle-level server to generate the image.

[0121] (10)

[0122] In the formula, New image data generated by the generator of the mid-level server;

[0123] The input parameters of the discriminator in the intermediate server include: new image data generated by the generator in the intermediate server and the original data, to obtain the discrimination result of the image;

[0124] Then use the discriminator of the middle-layer server. The discriminator loss function of the mid-level server is as follows: The newly generated image is distinguished from the original image (real data).

[0125] (11)

[0126] In the formula, The loss value of the mid-level server discriminator. To determine the distribution of real data The expectation, representing the distribution of real data. Data obtained from mid-sampling Expectations For the first Generator of a mid-level server random noise The output mapped to the data space, i.e., the fake samples generated by the generator. For the first The discriminator of the intermediate layer server For generated samples The output of the judgment is the probability that the discriminator determines the generated sample to be real data. For the first The discriminator of the intermediate layer server For real data The output is the probability that the discriminator determines the real data to be real data. The representative parameter is of Distributed data ;

[0127] To facilitate discrimination by the discriminator on the top-level server, the intermediate server needs to encode and compress the generated image data into an intermediate feature vector. This vector, along with the intermediate representation of the generated data, can then be uploaded to the top-level server. The encoding and compression must satisfy the following:

[0128] (12)

[0129] In the formula, It is a pre-trained convolutional neural network that generates image data. The input is fed into a CNN, which extracts features from it, and the result is a compressed intermediate feature vector.

[0130] in, It consists of 4 layers, including convolutional layer 1: 3×3 convolutional kernel, 16 filters, ReLU activation, pooling layer 1: 2×2 max pooling, convolutional layer 2: 3×3 convolutional kernel, 32 filters, ReLU activation, pooling layer 2: 2×2 max pooling, and output: flattening the feature map into a 128-dimensional feature vector.

[0131] Step 3) The top-level server receives the features transmitted by the mid-level servers. The output of the mid-level servers is the intermediate representation of the data generated by the mid-level servers and the discrimination result of the generated data. Since the top-level server does not have a generator, it needs the data generated by the mid-level servers to make discrimination. However, directly transmitting image data would put too much pressure on communication. Therefore, the intermediate representation of the data generated by the mid-level servers is transmitted to the top-level server as input for discrimination. The global discriminator is trained to judge whether the stitched complete image is real or fake and feeds the judgment result back to the generators of each mid-level server. The generators of the mid-level servers optimize their training parameters based on the judgment results and ensure training stability through gradient penalty. Then, the discriminator parameters of the top-level server are sent down to the discriminators of the mid-level servers. The mid-level servers then send the discrimination results of the top-level server and the mid-level servers together to the client. The client's generator also optimizes its training parameters based on the judgment results and ensures training stability through gradient penalty.

[0132] That is, the input parameters of the global discriminator in the top-level server include: the intermediate representation of the new image data generated by the generator in each intermediate server, the discrimination results of the discriminator in each intermediate server on the image and the original data, to obtain the global discrimination result and its network parameters;

[0133] The loss function of the global discriminator is:

[0134] (13)

[0135] In the formula, , These represent intermediate feature vectors from the real data and the generated data, respectively. for , These are gradient penalty weights, set manually rather than by computation, to avoid the influence of excessively weak or strong constraints. You can set a range, usually between 5 and 20, with 10 being a commonly used default value. The gradient penalty term is given by the following formula:

[0136] (14)

[0137] In the formula, It is a linear interpolation of the intermediate feature vectors between the real data and the generated data.

[0138] Step 4) Each layer begins to send parameters to the next layer, updates the parameters of each node device, and continues training until the training round is reached;

[0139] The top-level server feeds back the discrimination results of its discriminator and its network parameters to the discriminator of the middle-level server. After the discriminator of the middle-level server is updated, it feeds back the discrimination results of the image by the discriminator of the middle-level server and the discriminator of the top-level server to the generator of the middle-level server. The generator of the middle-level server then feeds back the discrimination results of the two discriminators and the part of the generator network parameters belonging to the client to the generator of the corresponding client. The generator of the client optimizes its own training parameters according to the feedback results. After training is completed, the generator of the client generates the enhanced data.

[0140] Step 4: Each layer begins to distribute parameters to the next layer, updates the parameters of each node device, and continues training until the corresponding training round is reached. Training rounds These parameters are set manually based on the difficulty of the training task and belong to the hyperparameters of this federated learning framework.

[0141] In this embodiment, the It is 300.

[0142] Step 5: Input random noise and the original dataset into the trained two-layer federated structure to obtain the generated data;

[0143] Each trained client collaboratively generates data to expand its own dataset to adapt to downstream tasks, thus concluding the data augmentation process.

[0144] The original client dataset was After data augmentation, the client's dataset becomes:

[0145] (15)

[0146] In the formula, A dataset consisting of high-quality data generated during the data augmentation process;

[0147] The generation process is as follows: After the client trains its own generator, it uses the data it possesses. Determine the type of data you want to generate, and then consider the amount of data you possess as mentioned in step one. Determine the approximate amount of data to be generated, and then begin generating the data. .

[0148] This invention presents a multi-layered, federated generative adversarial network (GAN) data augmentation method. The client deploys only the generator, eliminating the need for a discriminator. It trains independently using perceptual loss, uploading parameters only at the end of the training cycle rather than in batches of data or gradients—meaning local training occurs only on the client side. The mid-layer server transmits only abstract features, not complete images, significantly reducing the data volume; that is, the mid-layer server only performs feature-level transmission. Through a two-layer federated structure, feature splitting instead of data splitting naturally reduces communication requirements, thereby significantly lowering communication overhead and computational burden. Compared to traditional generative data augmentation methods, this method greatly reduces both communication volume and client-side computational load.

[0149] Although embodiments of the present invention have been disclosed above, they are not limited to the applications listed in the specification and embodiments. They can be applied to various fields suitable for the present invention. For those skilled in the art, other modifications can be easily made. Therefore, without departing from the general concept defined by the claims and their equivalents, the present invention is not limited to the specific details and embodiments shown and described herein.

Claims

1. A method for multi-layered cross-hierarchical federated generative adversarial network data augmentation, the method comprising: Includes the following steps: Step one, collect the location of the client that needs to be data enhanced, the number of clients , the location of the server device and the number of data ; Step 2: Determine the intermediate server; Step 3: Select a top-level server from all the mid-tier servers; Step 4: Construct the first-layer vertical federation structure from the client to the middle-tier server and the second-layer horizontal federation structure from the middle-tier server to the top-tier server. This includes the following steps: Step 1: Build the self-model of all node devices: All client, mid-level server, and top-level server models are GAN models, with the client consisting only of a generator and the top-level server consisting only of a discriminator. Step 2: Initialize all node devices, load the required parameters, and prepare for data augmentation calculations; The parameters include: the parameters of the generator in the client, the parameters of the generator and discriminator in the middle-layer server, the parameters of the discriminator in the top-layer server, the autoencoder parameters of the client, and the autoencoder parameters of the middle-layer server. Step 3: Train the constructed two-layer federation structure until the required training rounds are reached; Step 5: Input random noise and the original dataset into the trained two-layer federated structure to obtain high-quality generated data; Step 6: Combine the generated high-quality data set with the original data set to form the enhanced dataset.

2. The multi-layered, cross-layered, federated generative adversarial network data augmentation method according to claim 1, characterized in that, Step two includes: The intermediate server is determined based on the relative distance between the client and the server and the degree of data similarity between clients.

3. The multi-layered, cross-layered, federated generative adversarial network data augmentation method according to claim 2, characterized in that, Step three specifically includes the following steps: Step (a): Calculate the location center point between all mid-tier servers: ； In the formula, The location center point for all mid-tier servers, and , Represents the number of mid-tier servers; Step (b): Select the middle-level server closest to the location center point as the top-level server. ； In the formula, The location of the top-level server. To make the function take the minimum value value.

4. The multi-layered, cross-layered, federated generative adversarial network data augmentation method according to claim 3, characterized in that, Step 3 specifically includes the following steps: Step 1) Train the generator in the client; The input parameters of the generator in the client include: a random noise vector and the width of the overlapping image sub-regions; the output parameters are the overlapping images and their network parameters. Step 2) The mid-level server dynamically allocates client parameter aggregation weights based on the generator's training loss in the client, for adversarial training of its own model; The input parameters of the generator in the middle-layer server include: the overall network parameters after effectively concatenating the network parameters of the generators in multiple clients and a random noise vector; the output parameters are the generated new image data and its intermediate representation. The input parameters of the discriminator in the intermediate server include: new image data generated by the generator in the intermediate server and the original data; the output parameter is the discrimination result of the image data. Step 3) The top-level server trains a global discriminator based on the features transmitted by the middle-level servers; The input parameters of the discriminator in the top-level server include: the intermediate representation of the new image data generated by the generator in each intermediate server, the discrimination result of the discriminator in each intermediate server on the image and the original data, and the output parameters are the global discrimination result and its network parameters. Step 4) Each layer begins to send parameters to the next layer, updates the parameters of each node device, and continues training until the training round is reached.

5. The multi-layered, cross-layered, federated generative adversarial network data augmentation method according to claim 4, characterized in that, Step 4) specifically includes: The top-level server feeds back the global discrimination result and its discriminator's network parameters to the discriminator of the middle-level server. After updating, the discriminator of the middle-level server feeds back its discrimination result for the image data and the top-level server's discrimination result for the image to the generator of the middle-level server. The generator of the middle-level server then feeds back the network parameters belonging to the client and the obtained discrimination result to the generator of the corresponding client. The generator of the client optimizes its own training parameters based on the feedback result. After reaching the training rounds, the client generates high-quality data.

6. The multi-layered, cross-layered, federated generative adversarial network data augmentation method according to claim 5, characterized in that, The width of the overlapping image sub-region satisfies: ； In the formula, The width of the overlapping image sub-region. The original image width, The width of the overlapping region is represented by / / , which indicates truncation of decimal places for integer division.

7. The multi-layered, cross-layered, federated generative adversarial network data augmentation method according to claim 6, characterized in that, The training objective loss function for the client generator is: ； In the formula, For the first The total loss value of the generator for each client, For mathematical expectation, The random noise input to the generator. To start from the prior distribution Mid-sampling , For the first A generator network for each client based on noise The generated image, The data is real data collected from the client. To perceive loss.

8. The multi-layered, cross-layered, federated generative adversarial network data augmentation method according to claim 7, characterized in that, The generator output of the middle-layer server satisfies: ； In the formula, New image data generated by the generator of the mid-level server. For the first A generator for a mid-tier server. For the first During the round of iteration, the first The intermediate representation of network parameters is obtained by effectively concatenating the generator network parameters of each client in the cluster of intermediate-level servers.

9. The multi-layered, cross-layered, federated generative adversarial network data augmentation method according to claim 8, characterized in that, The discriminator loss function of the middle-layer server satisfies: ； In the formula, The loss value of the mid-level server discriminator. To determine the distribution of real data Expectations for random noise The output mapped to the data space, Discriminator for mid-level servers For generated samples The judgment output, Discriminator for mid-level servers For raw data The output, The representative parameter is of Distributed data .

Images