A Distributed Generative AI Approach for Heterogeneous Multi-Domain Environments under Data Sharing constraints
Authors: Youssef Tawfilis
Hossam Amer
Minar El-Aasser
Tallal Elshabrawy
Venue: Accepted by TMLR ()

Abstract: Federated Learning has gained increasing attention for its ability to enable multiple nodes to collaboratively train machine learning models without sharing their raw data. At the same time, Generative AI—particularly Generative Adversarial Networks (GANs)—have achieved remarkable success across a wide range of domains, such as healthcare, security, and Image Generation. However, training generative models typically requires large datasets and significant computational resources, which are often unavailable in real-world settings. Acquiring such resources can be costly and inefficient, especially when many underutilized devices—such as IoT devices and edge devices—with varying capabilities remain idle. Moreover, obtaining large datasets is challenging due to privacy concerns and copyright restrictions, as most devices are unwilling to share their data. To address these challenges, we propose a novel approach for decentralized GAN training that enables the utilization of distributed data and underutilized, low-capability devices while not sharing data in its raw form. Our approach is designed to tackle key challenges in decentralized environments, combining KLD-weighted Clustered Federated Learning to address the issues of data heterogeneity and multi-domain datasets, with Heterogeneous U-Shaped split learning to tackle the challenge of device heterogeneity under strict data sharing constraints—ensuring that no labels or raw data, whether real or synthetic, are ever shared between nodes. Experimental results shows that our approach demonstrates consistent and significant improvements across key performance metrics, where it it achieves an average 10% boost in classification metrics (up to 60% in multi domain non-IID settings), 1.1×—3× higher image generation scores for the MNIST family datasets, and 2×—70× lower FID scores for higher resolution datasets, in much lower latency compared to several benchmarks.

Published in Transactions on Machine Learning Research (01/2026)
A Distributed Generative Al Approach for Heterogeneous Multi-Domain Environments under Data Sharing constraints
Youssef Tawfilis
youseefalberr0gggc.cd
The Foculty of Information Engineering and Technology
The German University in Cairo
Hossam Amer
hossam.amerrgucccommm edu. eg
The Foculty of Media Engineering and Technology The German University in Cairo
Minar Elaasser
minar. saauureelassser@uuce www.eedu..uaeeeeeoeeoooooooo.a.. eg
The Faculty of Information Engineering and Technology
The German University in Cairo
Tallal Elshabrawy
tollal. halla.elshabrowwy@gua...kk
The Focully of Information Engineering and Technology
The German Universily in Cairo
Reviewed on OpenReview: https: // openreview. net/ forun? rd=pbbL7pfPY3
Abstract
Federated Learning has gained increasing attention for its ability to enable multiple nodes to collaboratively train machine learning models without sharing their raw data. At the same time, Generative Ar-particularly Generative Adversarial Networks (GANs) achieved remarkable success across wide range of domains, such as healthcare, security, and Image Generation. However, training generative models typically requires large datasets and significant computational resources, which are often unavailable in real-world scttings. Acquiring such resources be costly and inefficient, especially when many underuti- lized devices-sude as ToT devices and edge devices-with varying capabilities remain idle. Moreover, obtaining large datasets is challenging due to privacy concerns and copyright restrictions, as most devices are unwilling to share their data. To address these challenges, we propose a novel approach for decentralized GAN training that enables the utilization of distributed data and underutilized, low-capability devices while not sharing data its raw form. Our approach is designed to tackle key challenges in decentralized environments, combining KLD- weighweghteed Clustered Federated Learning to address the issues of data hetero- geneity and multi-domain datasets, with Heterogencous U-Shaped split learning to tackle the challenge of device heterogeneity under strict data sharing constraints ensuring that no labels or raw data, whether real or synthetic, are ever shared between nodes. Experimen- tal results shows that our approach demonstrates consistent and significant improvements across key performance metrics, where achieves an average 10% boost in classification metries (up to 60% in multi-domain non-IID settings). 1.1x-33 higher image generation scores for the MNIST family datasets, and 2x-70x lower FID scores for higher resolution datasets, in much lower latency compared to several benchmarks. Our code is available at https:/ http://itttriidddeegee -en--iignnnigggg ge.-ai..itttbb................ github.io, io wwwhhuusaaaaaa sorff-ggn.gge.. can..gituu.io/
1 Introduction
Generative artificial intelligence has captured global attention across every domain, including health- care (Showrov et al. 2024 securitty LLm et al. 2024). image synthesis (Lang al. 2021). and data

---

Published in Transactions on Machine Learning Research (01/2026)
Table 1: Evaluation of Distributed GAN Techniques Against Key Challenges
2022
Weseeinghee ee all 90024
Wijeinnee prae
Kassuu & Hosa 2003
Jain &e Wilfree Godlier
jeoinnge el. 2003
2
2022
Gueer FA ml ml.
20/3
Zhnan ee all 2021
(ootoooi es 2322
el all 2002
E-haon 20222
Chiaro el 2023
CSo 502
Malinkel et al 2022
Zinoo et m. 2022
Baggh et ml 2000S
Quan 0S 2012-00
21244
HoSCF-GAN
Banty 0C a
CG mL
Pith & Lin
Mr OE A.
Recouli
Zinto et
Cricerion
Data Heterogencty
Device Heterogmmiity
SSSS
Resouree Constritned Eavtrooments
Malti- Domain
Raw Daaa/ LLaall Shared
augmentation (Amer ct al. 2024 These models not only understand and analyze data but also generate entirely new content that ideally reflects the underlying distributions of their training data. However, training such models demands both massive volumes of diverse data and vast computational power (Manduchi et al. 2024 Amer et al. 2026).
Meeting these requirements is often challenging, as the majority of today's data remains siloed due to privacy, security, and proprietary concerns. These restrictions prevent clients and devices from sharing their data centralized entity, limiting the breadth and diversity of centralized training datasets and, by extension, the performance of centralized models depending on them. Morcover, centralized training infrastructures cesterss-uuse be powerful enough to accommodate growing
whether on-premises servers cloud-based model sizes and are correspondingly costly in terms of cloud subscription fees or, if on-premises, hardware, electricity, cooling, and land costs, making scalability difficult and fees prohibitive (Abul-Fazl el al. 2025 This is especially true as the amount of computing power used to train Al models is growing at a staggering pace- doublig roughly every 3.4 months. That is far faster than the rate predicted by Moore's Law, which estimates computing capacity to double approximately every 24 months (OpenAl & Stanford HAT 2023 Meanwhile, countless underutilized devices at the smartphooo,,, tablets, ToT devices sit idle despite possessing significant collective computational capacity; individually. However, none handle the workload of full-seale generative model, such as GANs [Goodfellow et al. 2020
Decentralized paradigms such as Federated Learning (McMahan et al. 2017) and Split Learning (Vepakomma et al. 2018) offer promising alternatives by enabling collaborative model training across distributed, privacy- preserving devices without exposing raw data or relying on contralized computational resources. Federated Learning allows multiple devices collaboratively train a shared model without exchanging raw data. Each device trains local copy of the model on its private dataset for several epochs, and then server collects them, aggregates them, and redistributes them. Split Learning, the other hand, is specifically designed to address the limitations of resource-constnn constrre- devices-sude as IoT devices- ttht are incapable of training an entire model locally. In its basic form, the model divided into two segments: a client-side portion and a server-side portion. Training begins at the client, which sends its activations to the server to continue training.
While decentralized paradigms offer a promising solution the problems regarding training centralized generative models, they introduce their own challenges. First, data heterogencity devices often hold non-IID data with varying label distributions, skewness, and dataset sizes can destabilize the global model when participants' local distributions differ widely. Second, utilizing underutilized devices introduces the challenge of device hetcrogencity in resource-constrained environments -ardd devices vary in compute power and data rates, so assigning equal workloads can cause bottlenecks and slow down training. Third, devices may hold data from different domains, which can degrade performance aggregation ignores these differences; effective methods must detect and adapt to such variation. Finally, ensuring data sharing constraints remains paramount: no device should ever share its raw (or generated) data or labels, and the training process must guarantee that sensitive information never leaves the device.
2

---

Published in Transactions on Machine Learning Research (01/2026)
Most recent efforts on decentralized GANs have typically addressed only one or two of the aforementioned challenges, as shown in Table | While these approaches offer promising ideas, they fall short of providing a comprchensive, real-world solution suitable for heterogencous environments. In this paper, we introduce Heterogeneous U-shaped Split Clustered Federated GANs (HuSCF-GANs)) a novel approach that enables collaborative training in heterogeneous settings across underutilized edge and loT devices with the support of an intermediary server without relying on it exclusively. Although demonstrate our approach using conditional GANs (cGANs) (Mirza & Osindero 2014), the same concepts can be applied to any generative
model.
Our approach proceeds in five stages.
1. First, we employ a genetic algorithm to determine the optimal cut points in the model for each client, based on its computational capacity and data transmission ratc, with the remainder of the model hosted on the server.
2. Next, we perform Heterogeneous U-shaped Split Learning on each client's portion of the model according to these tailored cuts, sending and receiving the activations /gradiietssssaasssssgeemmme to and from the server depending on the cut layers to continue its training.
3. Every several epochs, we apply a clustering technique to the clients' activations of the Discriminator's intermediate layer hosted on the server, grouping them into domain-specific clusters.
4. Within each cluster, we execute a federated learning routine that weighs each device's parameter updates by both its dataset size and its Kullback Leibler divergence score.
5. Finally, test and evaluate HuSCF- GAN against alternative decentralized frameworks across multiple benchmark datasets, demonstrating its superior performance.
MISCF--AN successfully addresses several key challenges: data heterogeneity, characterized by non-lll data distributions across clients; multi-domain data, where clients can possess data from different domains; and device heterogeneity, involving variability in computational power and data transmission rates among participating clients. Importantly, all of this is achieved under strict data-sharing constraints, specifically: no sharing of raw data neither real nor generated data is exchanged, with only intermediate activations and gradients being communicated; and no sharing of labels, thereby preserving the confidlnnialityy of local annotations.
The proposed approach was evaluated against several baselines, including MD-GAN (Hardy et al. 2019 FedGAN (Rasouli et al.) 2020). Federated Split GANs (Kortoçi et al.) 2022), PFL-GAN (Wijesinghe et al., 2023), and HFL.-GAN (Petch et al., 2025). HuSCF-GAN achieves up to 2.2x higher image generation scores and an average 10% improvement in classification metrics (with gains of up to 50% in some test cases) while maintaining lower latency compared to other approaches, demonstrating its effectiveness without introducing significant computational or communication overhead.
The remainder of this paper is organized as follows. Section 2 provides the necessary background to understand the core concepts presented in this work. Section reviews the existing literature related to distributed
GANs, Section 4 details the proposed methodology of our HuSCF-GAN Approach. Section 5 describes the experimental setup, while Section O presents and analyzes the results. Finally, Section S concludes the paper and discusses potential directions for future research.
2 Background
2.1
Federated Learning
Federated Learning (FL), introduced in 2016, is a distributed learning framework that enables multiple nodes to collaboratively train machine learning models without sharing their local data as shown in Figure ! Instead, after several training epochs, each node shares its model parameters, which are then averaged to produce global
learning from all datasets without compromising data privacy (McMahan
3

---

Published in Transactions on Machine Learning Research (01/2026)
Federated Learning
Regular Split Learning
U-Shape Split Learning
Server
Server
Server
wnight
Glidted Roodd
Weightt
Activation
Clients
Ciient
Client
Figure 1: Comparison between Federated Learning, traditional Split Learning, and U-shaped Split Learning. In Federated Learning, each client trains local model for several epochs and then sends its model weights to central server. The server aggregates these weights-typices model back to the clients. This process is repeated for multiple rounds. In traditional Split Learning, the model is divided into two parts: the client holds the imitial segment, and the server holds the remaining part. In U-shaped Split Learning, the model is split into three segments: the client retains both the initial and final segments, while the server manages the middle segment.
by averaging- and sends the updated global
et al. 2017
The overall objective in FL is to minimize the global loss function defined over the data distributed across all participating clients.
2.2 Split Learning
Another distributed learning paradigm is Split Learning, which in its vanilla form operates as follows: the neural network is split into two parts-thee the client part and the server part- whheee the first part resides the client device, such an edge node, and the other part resides the server. These two parts work sequentially, where the client part is trained first on the data (which remains on the client), then it sends the "smashed data" (activations) to the server to complete the forward pass and calculate the loss. The process is reversed in the backward pass with the gradients being sharod instoad of the activations. However, in the vanilla form, the labels must be shared with the server for loss calculation. This issue mitigated in the U-shaped variant of Split Learning, where the model is divided into three parts: the head, the tail, and the middle part. In this sctup, the head and tail reside the client that both the labels and the raw data remain local, while the middle part resides the server /Vepakomma et al. 2018 as shown in Figure |
2.3 Split Federated Learning
Split Federated Learning (SFL) a distributed Al framework that combines the principles of both FL and SL, as described in Subsections 2.1 and [.2 respectively (Thapa et al. 2022). In this framework, the model is split between each client and the server. The client-side segments of the model perform federated learning among themselves, enabling collaborative training while preserving data locality and reducing individual device workloads. The overall architecture of SFL is illustrated in Figure] 2
2.4 Conditional Generative Adversarial Networks
Conditional Generative Adversarial Network (cGAN) is an instance of a generative model, particularly GAN architecture, designed to enable class- or condition-specific data generation. Unlike vanilla GANs (Goodfellow et al. ) which generate outputs solely from a noise vector, cGANs condition both the Generator and the Discriminator auxiliary information-typlnn typically class labels or other side information-alllll alloowinnn the model to produce outputs that adhere to specific categories (Mirza & Osindero 2014
4

---

Published in Transactions on Machine Learning Research (01/2026)
Client
Ciient
Server-Side
Globall Cllene with Monill
Global Cilent Cilent-Side Moriel
Weiggn
Server
Weights
Actiratione
Grottlente
Activations
Aelvattons
Graditmns
Activntion
Gradient
Gradiaants
Globat Sidre-Side Model
Global Citere SUD Modil
Nteihht
Weights
Client
Client
Client
Cliant 4
2
Figure 2: SFL architecture: In the first step (split learning), clients train their local (client-side) model segments and send the resulting activations to the server, which continues training on the server-side segments. During backpropagation, the server returns the gradients to the clients. Tn the second step, after several local epochs, clients send their updated client-side models to the server for federated aggregation and redistribution.
In the cGAN framework, both networks receive the conditioning variable y as an additional input. The Generator G learns to map a noise vector p=(2) and condition y to the data space, i.c., G(=ly), while the Discriminator D is trained to distinguish between real data samples paired with their true condition and synthetic samples generated by G.
The training process formulated as a two-player minimax game. The objective function for a cGAN is defined as follows:
min max GDD E Ex [log D(rly)) + E (z) -DCCclllll G
D(G(elv))))
(1)
D
Here, x ~ (x) denotes real data samples from the true data distribution, = ~ (=())> is the input noise vector, and y is the conditioning information. Both and are explicitly conditioned on y, enabling class-specific synthesis and discrimination.
Images (x)
Labels (y)
D
Real/Fake
Noise
Fake Images G(zly)
Labels (y)
Figure 3: Architecture of a Conditional GAN (cGAN). The generator and discriminator are both conditioned on auxiliary information, such as class labels, allowing the model to generate data that adheres to specific conditions.
As illustrated in Figure 3 the incorporation of the conditioning variable allows for more controlled and targeted generation. This makes cGANs particularly effective in applications such as class-conditinnal image synthesis, image-to-image translation, and text-to-image generation, where the ability direct the output is essential.
The reason for choosing conditional GAN (cGAN) instead of vanilla GAN as the generative model is to enable the generation of synthetic data along with their corresponding labels. This allows us to train
5

---

Published in Transactions on Machine Learning Research (01/2026)
classifier on the generated data and evaluate its performance on a real test dataset by calculating the appropriate metrics, thereby assessing the effectiveness of the distributed approach.
3 Related Work
Several distributed learning frameworks and paradigms have been proposed to distribute GAN models across multiple devices or nodes. MD-GAN (Hardy et al.] 2019) was the first distributed GAN framework, in which single generator resides on the server to reduce the computational burden clients, while multiple discriminators are deployed on edge devices. The generator produces batches of synthetic data and sends them to the discriminators. Each discriminator computes its own loss, as well as the generator's 's loss, which is then sent back to the server and averaged. Additionally, the discriminators are periodically swapped among clients to prevent overfitting. Multi-Generator MD-GAN (Jain & Wilfred Godfrey 2022) extends MD-GAN by training label-specific generators on the server side. UA-GAN (Zhang al. 2021) addresses data heterogeneity (non-i.i.d. data) in distributed GAN training. In this framework, a central Generator resides the server to alleviate client-side computational demands, while multiple discriminators are deployed the clients. The method aggregates all distributed discrininators into simulated centralized discriminator, where the overall odds value is computed as a weighted mixture of the odds values from local discriminators. Also, CAP-GAN (Zhang et al. 2023) proposes a novel approach for federated GAN training within the Mobile Edge Computing (MEC) paradigm. However, it suffers from limitations such as reliance on a large number of edge servers and the transmission of generated data over the air. These four approaches address data heterogeneity and resturce-cnnstrained environments but doesn't consider device heterogeneity, multi-domain clients, and data sharing constraints, they involve sending synthetic raw images from the server to clients. Although the data is synthetic, il still reflects the underlying distribution of the original datasets on which it was trained. This distribution should never be shared with any entity other than the participating clients, not even with the server.
FedGAN (Rasouli et al. 2020 applied Federated Learning (FL) to GANs, adopting the standard FL approach using the FedAVG algorithm to aggregate model updates. Similarly, GANs are used in federated scttings in (Fan & Liu, 2020), where either both the generator and discriminator, or only one of them, is federated. These methods address data sharing constraints by ensuring that no data or labels are shared outside of clients and also handle data heterogeneity in terms of varying local dataset sizes. However, they overlook challenges such as differing data distributions, device heterogencity, resoureo-constrained environments, and multi-domain dalasets.
FeGAN (Guerraoui et al. 2020 introduced a novel aggregation strategy by assigning scores to clients based on both the size of their local datasets and the Kullback-Leibler (KL) divergence between their local label distributions and global reference distribution, as shown in Equation / However, this method requires clients to share their label distribution statistics with the server, potentially raising privacy concerns. Fed- TGAN (Zhao et al.) 2021) follows a similar methodology but focuses tabular data. It uses centralized column encoders trained on shared client data statistics to initialize the model before proceeding with federated learning. FI.-Enhance (Chiaro et al.] 2023) and PerFed-GAN (Cao et al. 2022) utilize GANs to support or replace traditional FL frameworks. These approaches often involve sharing data either real or synthetic- with the server, which introduces significant data privacy risks. FLIGAN (Maliakel al., 2024) performs federated GAN training for incomplete tabular data by using federated encoding of columns, followed by GAN training with node grouping based on label distribution. Although these methods address data heterogeneity, they share the data distribution with the server and doesn't 't tackle device heterogeneily, resource-constrainet euvironments, and multi multi-domain datasets.
P(t) Q(1)
DKL (Q)) = Σ log
(2)
Federated Split GANs (Kortoçi al. 2022) combine split learning with federated learning to address device heterogeneity. In this approach, the generator resides the server, while multiple discriminators are distributed and split across edge devices based on their capabilities. The discriminators are federated and

---

Published in Transactions on Machine Learning Research (01/2026)
aggregated every few epochs using the FedAVG algorithm. While this approach handles device heterogeneity, resource-constrained environments, and varying client dataset sizes, it overlooks challenges related to multi- domain datascts and data heterogencity in terms of difforent data distributions. Additionally, it transmits synthetic data over the air to end devices.
Other approaches such as IFL-GAN (Li et al. 2022 and EFFGAN (Ebllom et al., 2022) attempt to mitigate data heterogencity using different strategies. IFL-GAN incorporates maximum mcan discrepancy (MMD) into the model averaging process to reduce distributional differences across clients. EFFGAN addresses the
issue by ensembling fine-tuned federated generators to produce synthetic data. PS-FedGAN (Wijesinghe ct al. 2024a) trains only the discriminator in a distributed fashion, while HFL-GAN (Petch et al. 2025) uses
hierarchical federated learning to manage data heterogeneity by grouping clients based on cosine similarity and performing local and global federations. OS-GAN (Kasturi & Hota, 2023) performs one-shot distributed GAN training by sharing locally trained GANs and classifiers, which are used to infer labels for generated samples and construct global dataset. These methods, along with FedGen (Zhao et al. 2025 and FLGAN (Ma) el al.pa.. 2023), address data heterogeneity and avoids raw data sharing, but they fall short in addressing device heterogeneity, resource constraints, and multi-domain scenarios.
Further, U-FedGAN (Wijesinghe el al., 2024b) operates by training the discriminators both on the client side and the server side, while all generators are hosted on the server. To preserve privacy, only the gradients of the discriminators- training with the generators. GANFed (Fan al. 2024) embeds a discriminator within the Federated Learning network, where it interacts with the shallow layers of the generator to form a complete GAN model. AFL-GAN (Quan et al. 2024b) and RCFL-GAN (Quan et al. 2024a) incorporate reinforcement learning and maximum mcan discrepancy (MMD) to handle data heterogeneity and enhance training efficiency in resourte-constrained environments by selecting a subset of clients for each training round. Another approach, AuxFedGAN (Haghbin et al.] 2025), integrates GANs into federated learning by utilizing a pre-trained Auxiliary Classificr- Gessifiir-GGAN to support a fodcrated classifier. While these methods effectively address data heterogeneity, resource constraints, and data sharing concerns, they do not consider the challenges posed by device heterogeneity or multi-domain datasets.
on real client data- are shared with the server to continue the collaborative
PFL-GAN (Wijesinghe et al. 2023) is an innovative approach that replaces traditional FL frameworks with a GAN-based solution. It trains a conditional GAN (cGAN) locally on each client's dataset. These locally trained cGANs are then sent to the server, which generates synthetic data and constructs refined datasets for each client. The similarity between client datasets is calculated using the Kullback Leibler Divergence (KLD) from latent representations of synthetic data, obtained via a pre-trained encoder. This method effectively handles data heterogeneity and multi-domain datasets but still does not address device heterogeneity or training resource-constraince devices.
Three notable approaches, HSFT. (Sun et al. 2025 ESFL. Zhu et al. 2024) and DFL (Samikwa et al. 2024 combine Split Learning and Federated Learning across multiple nodes, where each node holds only part of the model while the remainder resides on the server. Both mothods address the challenge of selecting the optimal cut point for each client based on their computational capabilities, employing heterogeneous cuts i.e. each client may have a different cut-to adapt accordingly. However, both approaches implement standard Split. Learning, meaning that labels are still transmitted from the client to the server. Moreover, the problem they tackle is simpler than ours: they only require selecting single cut per client. In contrast, our method involves selecting four cuts per client, as we apply U-shaped Split Learning to both the generator and the discriminator. This not only increases the complexity of the problem but also enhances the security of the system. Another approach (Wu et al., 2025) applies heterogeneous split federated learning, assuming each client has a different cut point. However, it does not specify how the optimal cut point is determined for each client-It just assigns different cut points to different clients.
As discussed above, while many existing works on decentralized GANs address the challenge of data heterogeneity, only few consider device heterogeneity and the limitations of resource-constrained devices. Even fewer tackle the scenario where clients possess datascts from different domains. To the best of our knowledge, none of the existing approaches simultaneously address all of these challenges while adhering to strict data sharing constraints -narrallnttnmmmly..... that no data is shared in its raw form, whether real or synthetic,

---

Published in Transactions on Machine Learning Research (01/2026)
and labels are never shared outside the client. Only intermediate activations or gradients are permitted to be exchanged.
4 Methodology
4.1 Overview
HuSCF-GAN, as illustrated Figure operates as follows. First, Each client's model is split between the client device and the server. The server determines the optimal cut points for each client using a genetic algorithm, taking into account both computational capacity and data transmission rate, with the objective of minimizing overall training latency across all devicos. Both the Generator and Discriminator are divided into three segments: Head, Server, and Tail. The client retains the Generator Head (GHr), Generator Tail (Gr), Discriminator Head (Dи), and Discriminator Tail (Dr), each of which contains at least one layer. The intermediate segments Generator Server (Gs) and Discriminator Server (Ds)~ are hosted on the server, shared among all clients, and each must also contain at least one layer, corresponding to the central layer of the Generator or Discriminator, respectively. The server maintains a mapping of clients to their associated server-side layers, which may differ across clients due to heterogeneous cut points.
Server
layer by sending
Device
Device
Devica
Calculase E.D based
activationn
Cluster
Device
Device
W 1000 "00
1 GULTI 10
G5
Ds
D
based
based
106" "00" '96" G+ Gr D., D:
H 1
GH
G=
D., D
Devic
bevice
1 B
Device
Devis2
Figure 4: HuSCF-GAN Overview: Clients first send device capabilities to the server, which uses a Genetic Algorithm to assign optimal cut points. Clients then perform U-shaped split learning, exchanging intermediate sudivationsggradieenn with the server. Every E epochs, the server clusters discriminator activations and computes intra-cluster KLD scores and perform an intra-cluster federated learning round whose aggregation weights consider both data size and KLD.
Second, Once the setup is complete, Heterogeneous U-Shaped Split Learning begins. In this stage, each client trains its 'head" section and sends the resulting activations to the server. The server concatenates these aclivations with those from other clients participaling in the same layer and continues the forward pass, combining activations across layers as needed. When a client's final server-side layer is reached, the server sends the corresponding activations back so the client can continue the forward pass through its "tail" section. This process is applied to both the generator and the discriminator during training. The backward pass follows the reverse path with the gradients being shared instead of the activations.
Third, after E epochs, the server applies clustering algorithm to the activations from the intermediate layer of the discriminator residing on the server (while processing real data). This algorithm groups clients into clusters based on activation similarity.
8

---

Published in Transactions on Machine Learning Research (01/2026)
Fourth, within each cluster, federated learning is performed using a scoring mechanism that considers both the size of each client's local dataset and the Kullback- Leibeer (KT.) divergence of its activations which is used as an alternative to sharing data labels. This helps address data heterogencity across clients.
Otheroise
Calculate Intra- cluster KLD Weights
Select Optimum Cuts using GA
Heterogenous U-shape Split Learning
Every E epoths
Activations Based Clustering
Clustered Federated Learning
For Rounds
Figure 5: Overview of the proposed HuSCF-GAN procedure.
Figure 1
present the complete procedure of our proposed approach diagram.
Table 2: Comprehensive List of Symbols and Their Definitions Used in This Work
Symbol
Description
G
Generator Discriminator
D
Gı, Gr
Generator Head and Tail Discriminator Head and Tail Parameters of Gи Parameters of Gı
Dh, Dr
OGn
OcT
0D
Parameters of DH Parameters of Dr Parameters of The Server-side Generator Part Parameters of The Server-side Discriminator Part Number of Epochs
ODr
lGs
ODS
E
K
The Clients Batch Size
b
FLOPs
Floating Point Operations
FLOPS
Floating Point Operations per second The local dataset size on client &
n
4.2 Latency Model
HuSCF-GANs implement Split Learning by selecting optimal cut points for each of the K clients. While the number of cut points is flexible and depends on the number of devices over which the model is distributed, we choose to distribute each client's model between the client and the server only, thereby selecting four cut points per client. This results in the following model components: the client-side Generator Head and Tail, the client-side Discriminator Head and Tail, and the server-side Generator Segment and Discriminator Segment. This selection is performed using genetic algorithm aimed at minimizing the total training iteration latency for the clients participating in the training process, based their computational capabilities and data transmission rates. To achieve this, we first need to define the latency model for the system, similar to the model described in (Sun et al., 2025), but with some differences as our model is GAN model with 4 cut points but their model is a traditional classifier with only one cut point.
The computational latencies for the clients depend on the total number FLOPs required for GH, Gr, Dus and Dr. the batch size used during these operations, and the computational capabilities of the clients, shown in:
b- (.
b- 1.78. for x E [GH, GT. DH. DT}
C.F
CBB k.
(3)
k.m
SakK
JKKK
9

---

Published in Transactions on Machine Learning Research (01/2026)
Here, The and T denote the Client's forward and backward propagation computational latencies, respectively, for client & and model segment a {GH, DH, Dr}. The term T6. (1a,e) represents the number of floating point operations (FLOPs) required for forward propagation either up to the cut layer during head training starting from the cut layer during tail training at layer 4,2, while 7 (4x,2) denotes the FLOPs required for backward propagation. The variable b is the batch size used during training, f& is the CPU frequeney of client k, and 6i represents the number of FLOPs executable per CPU cycle on client k.
While the computational latencies for the server segments per layer are described as follows:
bys Joks
Iaa fsks
by.DD
by
G2
Te. B.
Da
DD B
(4)
fehs
JaKs
Here, TS. TG. TD. and T represent the computational latency for the server-side Generator, and Discriminator respectively for a given layer i, where y represent the number of FLOPs needed while training the Generator, and Discriminator during Forward and Backward Propagation for the ith layer, fes and Ka represents the CPU frequency and The FLOPs per CPU cycle respectively for the server.
For the transmission latency, we describe the latency for both clients and the server as follows:
Rs b Er (1k,ar)
Tu.
for (Gu, GG,,Gr, Da, Dr}, de (F,
(5)
b. Eo Eollkor
11)
T b Eallk,o + +1) for E (G,
(6)
k
R₂
R2
Here, The represents the uplink transmission latency for client h and model segment Ir E {G Gr, Dn, Dr), during propagation direction ø E B). This term accounts for the time taken to send smashed data or gradients from the client to the server. Similarly, Tel and T denote the downlink transmission latencies from the server to client & for the Generator or Discriminator (vr {G, D}) during forward and backward propagation, respectively. The forward transmission (Td_.) occurs just before the client-side tail cut points (lwaz), while the backward transmission (THle) begins just after the head cut points (k,,0)) & (l) represents the size, in bytes, of the smashed data or gradients at layer I for model component x. The variables R and R2 denote the uplink and downlink transmission rates (in bytes per second) for client and the server, respectively. The batch size is denoted by b.
To define the total latency of the system, we first have to introduce the following equations:
+ Th ) for (G,D}
SF max
SF ST,111
S.S.F. No. REK been =i
max
(ICF
(7)
8B max
S +.....
$
No
max
(TC. kar
+ Tm, keer)
for E (G,
(8)
kEA laee
Here, ST, and SB represent the maximum cumulative latency from the first layer in the head segments to layer i and from the final layer in the tail segments down to layer i during forward and backward propagation, respectively, for x E (G, D} on the server side. The forward latency Sf, accumulates from the input (layer 0) to layer i, where the initial condition is S O. Similarly, the backward latency S accumulates from the output layer + 1 down to layer i, with initial condition S O, where is the index of the final layer of the side model for both Generator and Discriminator. The first term inside the outer max(-)
10

---

Published in Transactions on Machine Learning Research (01/2026)
represents the sequential server-side computation at layer i scaled by the number of participating clients N,, The second term accounts for the maximum latency among all clients whose cut layer (i.e., the boundary between client and server) is at layer i. Specifically, this includes the local client computation and the uplink transmission time needed deliver activalions (in lorward) or gradients (in backward) the server. The term N₁ is the number of clients participating this layer on the server side. If no clients are assigned to a given layer the server, N₂ = 0, and that layer incurs no server-side latency.
Now, the total latency is defined by the following equalions:
1T max (S.. kEY
(plleer-1 + The + kooT)
L max
( (a. -1 + Td.. BB k.n TT.B for x E {G.
(9)
kEK
L8 + 3 (LD + LB) LT LG
(10)
Here, E and T. represent the total forward and backward propagation latency, respectively, for model # E DG (Generator or Discriminator). The total system latency LT reflects the complete duration of one training iteration. includes the Generator's forward and backward passes and three instances of the Discriminator's forward and backward passes. The factor three accounts for the Discriminator being trained on batch of real data, batch of fake data, and once more when computing gradients used to update the Generator.
4.3 Selecting The Optimum Cuts
For our optimization problem, we employ genetic algorithm to minimize the total latency of the system by optimizing the variable, which represents the optimum four cut points for each client
1 C (..,, (x) 4 (l4,G Ir Da Dr)))
A major challenge lies its high complexity: since we aim to determine four cut points for each client, the search space grows exponentially with the number of clients. This makes convergence of the genetic algorithm increasingly difficult the client population increases. To address this issue and reduce the search space, employ reduction strategy where we reduce the total number of clients to the number of device profiles (Devices having the same computation capabilities). This approach maintains representativenss while significantly shrinking the optimization domain. as illustrated in Figure
1
Figure 6: Downsampling the number of clients while representing all different profiles.
This approach is shown to be able to reach the same sub-optimal value as a full genetic algorithm in appendix D To ensure the accuracy of latency evaluation, the fitness of each individual is always measured after upsampling the solution back to the original number of clients.
The procedure begins with the initialization of population of 1000 individuals. Each individual represents possible set of cut points for the clients and is typically encoded as array of client-specific cut points initialized randomly.
11

---

Published in Transactions on Machine Learning Research (01/2026)
A fitness function is used to evaluate how well each individual (i.e., each potential solution) performs. In our case, the fitness function is defined as:
(It = (I),
(11)
where (1) denotes the total latency corresponding the solution 1. Since the genetic algorithm is designed to maximize the fitness function, and our objective is to minimize latency, introduce negative sign to reverse the optimization direction. Alternative formulations, such as using the reciprocal of latency, can also be employed and are expected to yield equivalent results under our strategy.
After initializing the population of candidate cut-point configurations, the genetic algorithm runs for a predelined number of generations. In each generation, we evolve the population by applying the following steps, gradually searching for a configuration that minimizes total system latency:
1. Selection: We begin by selecting parents based on their fitness, which in our case is the negative of the total latency- where parents are the individuals with the highest fitness (lowest latency). To do this, we use tournament selection: five individuals are randomly chosen from the current population, and the one with the highest fitness (i.e., the lowest latency) selected as a parent.. This process is repeated to select a second parent.
2. Crossover: Next, the two selected parents are combined to create offspring according to a selected crossover rate. Crossover happens to explore new combinations of cut points across clients. We alternate with equal probability between:
Uniform crossover: Each parent shares half of its clients' cut points randomly.
Two-point crossover: Each parent split into three segments (Of clients' cut points) at two points, and segments are interchanged to produce diversity in the offspring.
3. Mutation: After crossover, we introduce small random changes by moving the cut points for some clients to other layers according to a selected mutation rate. This adds variation to the population and helps prevent the algorithm from getting stuck in a local minimum.
4. Elitism: To make sure we don't lose our best solutions, we carry over the top two individuals (combination of clients' cut points) from the current generation directly into the next one without any changes. This guarantees that the best configurations discovered so far are always preserved.
The algorithm repeats this process for several generations. Over time, the population improves, and the best solution found denoted as re-represents the set of cut points that achieves the lowest overall system latency.
4.4 Heterogeneous U-Shaped Split Learning
The split. learning process proceeds as follows. After the server determines the optimal cut points for each dlint-based on their computational capabilities it records which clients participate in which server-side layers. Duc to heterogencous cuts, this assignment varies across clients; however, the middle layer of both the generator and discriminator must reside the server, thus shared by all clients.
For each training batch of size b as shown in Figure 7 the forward pass begins with each client executing its local Generator Head (Gn) and transmitting its activation outputs to the server. At the first server-side layer, the server concatenales the activations received from all clients participating in that layer. For subsequent layers, the server concatenates its previous layer's output with the activations from the GH modules of clients whose participation starts at that specific layer. This continues until the middle layer is reached, which is shared by all clients. Beyond the middle layer, the server sends activation outputs back to the clients whose participation ends at each layer, so they can process their corresponding Generator Tail (Gr). The same procedure applies to the Discriminator.
During the backward pass, the same communication pattern is followed in reverse. Gradients propagated from the tail to the head, and the exchanged data are gradients rather than activations.
12

---

Published in Transactions on Machine Learning Research (01/2026)
G
Ds
GH
GT
DH
DT
Figure 7: Heterogeneous U-Shaped Split Learning: The model is divided between the client and the server hence the term split learning. It is described as U-shaped because the initial and final segments of the model reside on the client side, while the intermediate portion is hosted the server, forming U-like structure as indicated by the arrows. The term helerogeneous indicates that different clients may use different. cut points for splitting the model.
4.5 Clustered Federated Learning
Every E epochs, round of federation is performed. During the first two rounds, no clustering Kullback- Leibler Divergence (KLD) weighting is applied, (edAVG(MMMaalle allowing the local models to mature and produce meaningful outputs. After these initial rounds, and before each subsequent round of federation, we apply clustering algorithm to the activations of the middle layer of the discriminator, which is shared across all clients as described in Subsection 4.4
al. 2017) is applied in its vanilla form
This clustering is performed during the Discriminator's training on real data, as real data typically yields (nn/2) denote the average activation vector more informative feature representations. For each client k, let 0i,D from the middle layer of the Discriminator, where np the total number of Discriminator layers. The middle
layer, n2/2, is shared across all clients, and clustering is performed on its activation vectors.
We collect the activation vectors from all clients and input them into a KMeans clustering algorithm:
labels = KMcans ((okD S SKEK)
(12)
where each cluster label labelg labels corresponds to client k. Each cluster represents clients whose datasets originate from the same or similar domains. After clustering, calculate how each client's distribution diverges from the other clients' distributions within the same cluster by using the Kullback-Leibbee Divergence (KID)) score.
To compute this, we follow these steps:
First, we take the averaged activations of all clients and apply the softmax function each:
Ps Softmax (2 vk E K
(13)
Next, for each client k we compute the average distribution of the other clients in its cluster Ck
13

---

Published in Transactions on Machine Learning Research (01/2026)
Σ P REC a.E
Pj = -
(14)
[Ckl
Then, we calculate the KLD between P& and Pj using
2 and denote it by KLD
Finally, use the KLD score along with the dataset size to define the weighting score for intra-cluster
federated learning as follows:
Th e KLD.
(15)
Σ nj e- KLD, jEC²
where | scaling parameter. The equation written such that clients with larger dataset sizes should have greater weight, and clients with higher divergence from the group should have lower weight. The choice of exponential decay an inverse function is due to its smoothness and numerical stability, ensuring the
avoidance of exploding weights when the divergence approaches zero, unlike the use of KLD
Then, Federated Learning is applied to update the parameters of the client-side model components for all clients within the same cluster as follows:
0++1 Σ
sk 00 AC, CC, f E (0c,. Pcr: 0 PD
(16)
kEC.
For the server-side model components, the parameters are updated using all clients collectively. In this case, the scoring mechanism described in [14] and (15) is applied globally across all clients, rather than per-cluster basis, since the server-side model is shared among all clients. Then the server-side model components are updated similar to that in 16 but with the global scores.
5 Experimental Setup
We sct up experimental environment using a conditional GAN (cGAN) implemented in PyTorch (Paszko 2019), following the archilecture described in Table 3 which comprises 3M parameters. This architecture is adopted as a proof of concept to demonstrate that we can effectively reduce total latency while still achieving strong performance. While real-world applications may require more complex architectures, the same methodology remains applicable. To simulate heterogeneous setting, we consider 100 clients whose profiles are randomly sampled from the device configurations listed in Table of which many are resource constrained loT devices. The reason for selecting this setup is that it includes profiles representing clients with varying computational capabilities ranging from weak to medium scenario. Moreover, the setup mimics configurations similar to those of actual devices, with realistic variations in computational power, rather than randomly assigning CPU froquency, FLOPs per cycle, or transmission rates. Setups from other papers were also experimented on, and yielded similar consistent results.
thereby simulating real-world
We evaluate the proposed system using the following benchmark datasets: MNIST [eeCun al. 1998 Fashion-MNIST (FMNIST) (Xiao et al. 2017), Kuzushij-MNNSS (KMNIST) (Clanuwat et al.
2018
and NotMNIST Bulatov| 2011p. We also evaluate our framework using CIFAR.10 (Krizhevsky el al. 2009) and SVHN Netzer et al. 2011] datasets to test the adaptability of our approach to higher resolution datasets. We also test our approach on medical imaging datasets (Yang et al. 2021]: BloodMNIST and DermaMNIST which are Blood Cell Microscope and Dermatoscope imaging to evaluate how our framework would perform on real world use case. Finally, to examine the cross-modal adaptability our framework, we conduct experiments on the AudioMNIST [ecker al. (2024) dataset, which represents the audio modality.
We compare HuSCF-GAN with E 5, hyperparameter B 150, population size PS 1000, crossover
rate CRR 0.7, and mutation rate M R 0.01 against several benchmarks MD-GAN HHrdy et al. 2019
14

---

Published in Transactions on Machine Learning Research (01/2026)
FedGAN (Rasouli et al. 2020 Federated Split GANs (Kortoci et al. 2022), HFL-GAN (Petch et al.,
2025 and PFI-GAN Wijesinghe et al. 2023), , all with the same cGAN architecture explained earlier to
cnsure fairness. The system's performance is evaluated and compared against bascline methods using three
metrics:
5
5
6
5
6 8 8 6
8
FCAD
DUDD WAHUCFFI
S
3
9
6
2
8
8
4
7 5 6
UCAD
IIC
/
7
7
9
6
GI WALU
9
2
0
7
G DA
2
0
5
6 3 0 1
H BB
HAA
5
1
2
4
9
9
2
1
CB
7
2
1
7
DAHAG
1
3
7
1
5
7 0
6
7
9
/
O
7
2
AB
G
(a)
MNIST
(b) Pashion-MNIST
(c) KMNIST
(d) NotMNIST
112
20
5
(e) BloodMNIST
(f) DermaMNIST
(g) CIFAR10
(h) SVHN
Figure 8: Sample images from the eight datasets used in our experiments: MNIST, Fashion-MNIST, KMNIST, NotMNIST, BloodMNIST, DermaMNIST, CIFAR1O, and SVHN.
1. Classification Metrics: A CNN model is trained exclusively on 30,000 generated samples (i.e., without using any real data), with labels uniformly distributed across classes. The model is then ovaluated on a real test set, which was not seen during training, to compute metrics such as Accuracy, Precision, Recall, F1 Score, and False Positive Rate (One-vs-All). This evaluation serves to assess the generative model by measuring how closely the distribution of generated data matches that of the real data. If the distributions similar, the classifier learns mcaningful features and achieves better scores. Conversely, if the distributions differ significantly, the classifier performs poorly.
Image Generation Quality: To evaluate the quality of gencrated images:
For the MNIST family datasets, adopt the metric introduced in (Hardy et al. 2019 inspired by the Inception Score (Salimans et al. 2016). This metric is computed using pre- trained, dataset-specific classifier in place of the Inception V3 model. The evaluation is performed separately for each dataset within the MNIST family.
For higher-resolution datascts such CIFAR-10 and SVHN, employ the Fréchct Inception Distance (FID) score (Heusel et. al.] 2017), it provides meaningful assessments for these domains. In contrast, the FID score is less appropriate for MNIITT-famil datasets due to their structural simplicity relative to the Incoption V3 model's expectations. (Lower FID scores indicate better image quality.)
3. Average Training Latency per Itcration: This measures the average computational time required for a single training iteration, providing insight into the training efficiency of the model.
Eight distinct scenarios are considered to evaluate the proposed approach across various test cases. The first scenario involves single-domain IID data, followed by single-domain non-llI data. Next, two-domain
15

---

Published in Transactions on Machine Learning Research (01/2026)
Table 3: Generator and Discriminator Architectures
Generator
Discriminator
Input: 0000 label R
Input: image 28x28, label R
Label embedding and roncatenation
Label embedding reshaped and concatenated with image
22625xx7 BatchNorm ReLU
Conv 2-+64, kernel 4x4, stride + BatchNorm L.ReLU
ConvT 256-+128, kernel 1x4, stride BatchNorm ReLU
Conv 61-+128, kernel 4x4, stride BatchNorm L.ReLU
ConvIT 128-+128, keruel 3x3, stride + BatchNorm ReLU
Conv 128- 128-+128, kernel 3x3, stride + BatchNorm L.ReLU
ConyT 128-x64, kernel 4x4, stride BatchNorm ReLU
Conv 128 128-+ kernel 4x4, stride BatchNorm L.ReLUU
ConvTT 64-+1, kernel 3x3, stride 1 Tanh
Flatten - FC Sigmoid Output: probability (real/fake)
Output: generated image 28
Table 4: Computation and Communication Capabilities of Devices
Device
Frequency (MHz)
FLOPs/cycle Transm. Rate (Bytes/s)
Device
480
50 106
Device 2
6000
8
150 106
Device 3
15600
8
1000 x 106
Device 4
3720
8
300 106
Device 5
4000
4
50 106
Device
9000
4
100 x 106
Device
12000
10
800 x 10c
Server 42000
16
1000 x 106
ID and bwo-domain non-llI scenarios are examined, including a more challenging two-domain non-llI
setting. To assess scalability, four-domain IID scenario is also included. Finally, two specialized scenarios are considered: two-domain non-IID) setting for medical imaging applications, and two-domain highly non-llD scenario for higher-resolution images.
6 Evaluation & Results
The experimental results evaluated using three key metrios: dataset-specifie image generation scores, classifier performance with 95% Wald confidence intervals, and training latency. These metrics assessed across both single-domain and multi-domain settings, under IID and Non-IID data distributions. Table 5 summarizes the different test scenarios upon which the evaluation is assessed. It is important to note that an ablation study conducted to evaluate different components of the approach is shown in appendix A Further results and comparisons are also demonstrated in appendix
Table 5: Summary of Test Sccnarios
# Domains
Data Distribution
Datasets Used
IID
MNIST
1
Non-IID
MNIST
2
IID
MNIST + FMNIST
2
Non-ITD
MNIST + FMNIST
2
Highly Non-IID
MNIST + FMNIST
4
IID
MNIST + FMNIST + KMNIST + NOUMNIST
2
Non-IID
BloodMNIST + DermaMNIST
2
Highly Non-IID
CIFARI0 + SVHN
1
Non-IID
AudioMNIST
16

---

Published in Transactions on Machine Learning Research (01/2026)
6.1 Image Generation Scores & Classifier Performance Comparison
We evaluate the performance of our algorithms against several baselines across six different scenarios, each representing a distinct data distribution.
6.1.1 Single-Domate IID Data
In the first scenario, all clients possess local datasets drawn from the same domain, with data being independent and identically distributed (ID). Specifically, we use the MNIST dataset, where each client. holds 600 images.
this scenario, all algorithms demonstrate similar performance in terms the MNIST score, as illustrated in Figure and classification metrics, as shown in Table However, our algorithm achieves slightly higher classifica tion metries compared to the others. This can be attributed to the simplicity of the scenario- it involves only single domain with IID data distribution, all algorithms perform well under these favorable conditions.
HuSCF-GAN Fed. Split GANs PFL-GAN HFL-GAN
FedGAN - MD-GAN
MNIST Score
5
Total Number of Epochs
Figure 9: MNIST score vs. Training Epochs Single-Domain IID Data: This Plot shows similar performance across all approaches
Table 6: Classifier Performance Single-Domain IID Data
MNIST Dataset
Accuracy
Precision
Recall 1
F1 Score
FPR
FedGAN
Rasouli et aL.
2020
97.3%
97.3%++..3
97. 97.31%:1..00 90 32
97 20.2%%
0.3%
MD-GAN Hardy
2015
16.33%
50.58%
96.51 10.36
96.5%:10.36
0.34%::0.12
Fed. Split.
94.72%:4..00 44
91.9%%00.43
91.69%.10.04
91.71%20.4
0.39%
GANs Kortogi 2022
PFL--GAN
Wijesingee et n1
2023
97.11%:LL0.8
97.12%
97.11 1..111 0.33
97. 1.
0.32%.11.11
Petch 2025
03.84%.+-0.4
93.92%
03.62%
93.8%++0.38
0.68%++0.1
HUSCF-GAN
97.71 2.22
97.73%=0..29
97.7%+0.22
97.69%=0.29
0.2
6.1.2 Single-Doma Non-IID Data
To increase the complexity of the previous test case, introduce non-IID characteristics the system.
In this scenario all clients possess local datasets originating from the same domain (MNIST), but the data
17

---

Published in Transactions on Machine Learning Research (01/2026)
distribution is non-ind non-independent and non-identically distributed (non-IID). The heterogeneity is simulated as follows: while some clients have access to the full set of labels, 40 clients have labels excluded, 10 clients have 3 labels excluded, and another 10 clients have 4 labels excluded. Additionally, the quantity of data varies across clients, with some holding 600 images and others only 400.
In this test case, performance differences between algorithms begin to emerge due to the added complexity introduced by the non-IID data distribution, despite the data still being from single domain. As shown in Figure T0 HuSCF-GAN, FedGAN, and HFL-GAN achieve the highest MNIST scores, with HuSCF-GAN demonstrating faster convergence rate. Furthermore, Table shows that HuSCF- GAN achieves the highest classification metrics among all evaluated algorithms, with up to a 4% increase accuracy compared to the others.
HuSCF-GAN FodGAN MD-GAN
Fed. Split GANs PFL-GAN HFL-GAN
9
MNIST Score
6
3
0
50
100
150
200
250
Total Number of Epochs
Figure 10: MNIST Score vs. Training Epochs Single-Domain Non-IID Data: This plot shows similar performance across all algorithms, with HuSCF-GAN FodGAN, and HFL-GAN achieving slightly higher scores than the others. Among them, HuSCF-GAN also demonstrates slightly faster convergence.
Table 7: Classifier Performance Single-Domail Non-IID Data
MNIST Dataset
Accuracy
Precision
Recall
F1 Score
PPR
FedGAN [aasouli
97.03%.10.33
97.04%10.33
97.04%110.33
0..33
0.33%
MD-GAN Thardy et al.
2015
96.01 % 0.38
96. 14% 0.38
95.97% +-338
16.99%-+-00 0.33
0.44%++0.13
Fed. Split
GANs Kortoci sl
2022
93.86%.110.47
93.96%.10.47
03.82%
93.8 93.84%%10.47
0.68%.10.16
PFL-GAN Wijssnghe R1
2023
92.41%:10.52
92. 92.41%.1..5 .22
92.41%:1..52
92 02.39%%.2.552
0.84%;20.12
HFL-GAN Petch
91.11%%.00
16%
94.41%%:...4
91.11%20.15
0.61%
HuSCF-GAN
97.17%=0.32
97.21 0..32
97.18%:1..32
97.15%
0.31%#t..11
6.1.3 two-Domaiin IID Data
We then begin introduce a multi-domain environment by allowing clients to hold data from two different. distributions. In this scenario, clients draw data from two distinct domains: 50 clients possess IID data sampled from the MNIST dataset, while the other 50 clients possess IID data from the FMNIST dataset. All clients have equal dataset size of 600 images.
18

---

Published in Transactions on Machine Learning Research (01/2026)
This scenario marks the beginning of the multi-domain experiments with the inclusion of a second domain, FMNIST. Among all evaluated approaches, only our method and PFT-GANN demonstrate strong performance across both the MNIST and FMNIST datascts, as illustrated in Figures 1la and 1ib This is due to the lact that only these two approaches are capable effectively adapting to nulti-domain environments, with HuSCF-GAN converging faster than PFL-GAN. In terms of evaluation metrics, as shown in Table @ our method achieves slightly better results than PFL-GAN, with equal slightly higher false positive rates (FPR), and significantly outperforms all other approaches with 20% to 80% increase in evaluation metrics such accuracy.
It is evident from Figures 1la and 11b that the remaining methods struggle to maintain consistent performance across the two datasets, often exhibiting fluctuations and instability. While Federated Split GANs demonstrate strong latency performance, remains incapable of handling multi-domain environments. In contrast, our approach maintains robust and stable results across both domains, achieving 1.3x to 2x higher MNIST and FMNIST scores.
HuSCE-GAN
PFL-GAN Fed. Split GANs
FedGAN HFL-GAN
MD-GAN
10
10
9
MNIST Score
7
FMNIST Score
7
50
100
150
200
250
50
100
150
200
250
Total Number of Epochs
Total Number of Epochs
(a) MNIST Score Training Epochs This plot shows the superior performance of HuSCF-GAN and PFL-GAN compared other algorithms, with HuSCF- GAN converging faster and achieving slightly higher score than PFL-GAN. contrast, other approaches exhibit noticeable fluctuations and instability.
(b) FMNIST
Training Epochs: This plot shows the superior performance of HuSCF-GAN and PFL-GAN compared other algorithms, with HuSCF. GAN converging faster and achieving a slightly higher score than PFL-GAN, contrast, the other approaches exhibit noticeable fluctuations and instability.
Figure 11: Image Generation Scores
IID Data
Table 8: Classifier Performance Two-Domains IID Data
Accuracy
Prectaion
Racall
PL
Accuracy
Prectalon
Recall
PAOGAN
Rasuel ww 2000
5345
340 GIAN
G1 (1.72883355
32.3275.1.01
17.77910..5
20.022.5551
7.02%:00.55
Pec Scln
17.825610.05
22:04
d5.21%an
3.928:20.38
12.477620.01
9.77529.29
3.70M:20.56
991. (2h Wiihenne Ra
2033
06.005-10.44
564175 10
06.072.-..34
00.00%....
0.0124...122
8:31551077
41.17544077
$1.312-8.77
81.1155.0.7
TuCCP GA
$6.9075
97.0776448..44
07:3175-0.33
0.3095-40.15
85.9075-0-77
40.79%5.0.12
63.01524.0.72
83.5475-00.0
1.229-40..0
19

---

Published in Transactions on Machine Learning Research (01/2026)
6.1.4 Swo-Domains Non-IID Data
Building on the multi-domain setup, we introduce non-IID characteristics further assess how well our algorithm performs compared to others. In this scenario, clients draw data from two distinct domains: 50 clients possess non-llD data sampled from the MNIST dataset, and the other 50 clients possess non-llD data from the FMNIST dataset. Within each domain, some clients have access to the full set of labels, while 20 clients have two labels excluded, 5 clients have three labels excluded, and another 5 clients have four labels excluded. Additionally, data quantity varies, with some clients holding 600 images and others 400.
In this scenario, data heterogeneity introduced through the non-III dist.ribution, increasing the overall evident that our approach outperforms all other methods in terms of MNIST and FMNIST scores, well as classification metrics- including PFI-GAN. While PFL-GAN delivers competitive results, it exhibits some difficulty in handling non-lID data, shown in Figures 12a and 12b and in terms of classification accuracy in Table g Our method achieves 1.1x to 1.125x better MNIST and FMNIST scores than PFL-GAN, and up to 2x better scores compared to other algorithms.. HuSCF-GAN achicves up to 5% higher evaluation metrics than PFL-GAN and a 10% to 80% improvement over the remaining methods.
complexity of the system.
Our approach consistently maintains stable and high performance across both datasets, in contrast to the performance degradation observed in PFL-GAN and the highly unstable behavior of the other algorithms.
HuSCF-GAN MD-GAN
PFL-GAN Fed. Split GANs
FedGAN HFL-GAN
10
10
8
8
MNIST Score
FMNIST Score
5
2
150
100
200
Total Number Epochs
Total Number Epochs
(a) MNIST Score vs. Training Epochs: This plot shows that HuSCF-GAN achieves the highest score, with performance approximately 1.1x higher than PFI-GAN and up to 1.6x higher than other algorithms.
(b) FMNIST score vs. Training Epochs: This plot shows that HuSCF-GAN achieves the highest score, with performance approximately 1.125x higher than PFT.- GAN and up 2x higher than other algorithms.
Figure 12: Image Generation Scores
Twoo-omaing Non-lII Data
Table 9: Classifier Performance Two- Moo-Domains Non IID Data
SINIST Dotaset
FANIST Datasot
Pe0AAN
Geemil
50 2230
21. Man
stup2aca 75
9.478
74.28
73.1155055
3.015-0.34
6AN Kergo 2m
50 9072--0-55
02 1033355-00
55 41150
90 0000724400 40
2135-0455 40
30 30.905540.00
4.295-8.55
1P: GAX
Predrees
30 102.4433 (0.33
00 01 0:030
42:54
38:155:00.0
7377-6651
00.377.00:0
23.122-0044
08.175510.00
47.005110.0
34155-0.66
Mo00F-GA
96. 10.28%0c00.37
08.159/20133
98.19%220.38
93.999620.77
83. 91.90%620.77
61.78%=0077
20

---

Published in Transactions on Machine Learning Research (01/2026)
6.1.5 Swo-Domains Highly Non- lon-IID Data
Another highly non-IID scenario is conducted in which clients draw data from distinct domains: 50 clients possess non-ITD data sampled from the MNIST dataset, and the other 50 clients possess non-ITD data from the FMNIST dataset. Within each domain, 20 clients have two labels excluded, and another 30 clients have three labels excluded. Furthermore, dataset sizes vary across clients some have 600 entries, others have 200, and few have only 100. This scenario introduces a more intense level of data heterogeneity compared to the previous one, further increasing the challenge for all algorithms.
Despite the added complexity, HuSCF-GAN continues to demonstrate stable and superior performance. As illustrated in Figures 13a and [3b, our method consistently achieves high MNIST and FMNIST scores, with a significant performance margin over all other algorithms bigorithms-achheving 1.2x to 2.1x higher scores. Additionally, our approach attains the highest classification accuracy, shown in Table 10 with improvements ranging from 10% to 40% MNIST and from 10% to 80% on FMNIST compared to all other algorithms. These
results highlight the robustness and adaptability of HuSCF-GAN in highly heterogeneous settings.
HuSCE-GAN MD-GAN
PFL-GAN Fed. Split GANs
FedGAN HFL-GAN
10
10
9
9
MNIST Score
FMNIST Score
7
3
50
100
150
200
250
50
100
150
200
250
Total Number of Epochs
Total Number of Epochs
(a) MNIST Score Training Epochs: HuSCF- GAN achieves scores that are 1.2x to 2x higher and significantly more stable compared to other approaches.
(b) FMNIST score Training Epochs: HuSCE. GAN achieves scores that are 1.15x to 2x higher and significantly more stable compared to other approaches.
Figure 13: Image Generation Scores Two-Domaing Highly Non-IID Data
Table 10: Classifier Performance Two-Domaing Highly Non IID Data
MINIST Disaset
PMNIST Dataset
YNGAA
Sansall st
cit 20.87
IT 373 u00.5
20 2s
Wei
Borton 2012
547 201.9
suee
Is su00iiau
0369 20.00
10 205
1.77
ac
76.11
27.219530.33
17.19%..
2.478.0.3
MPS-AN
851 31 79.72
Starraa0 30
1.103/010330
16.1096mm.30
6.1.6 Four-Domains IID Data
In this scenario, clients draw data from four distinct domains: 25 clients possess IID data sampled from the MNIST dataset, 25 from the FMNIST dataset, 25 from the KMNIST dataset, and the remaining 25 from the NotMNIST dataset. All clients have equal dataset size of 600 images.
21

---

Published in Transactions on Machine Learning Research (01/2026)
In the final scenario, the number of domains is increased from two to four by introducing the KMNIST and NotMNIST datasets. This setup is designed to evaluate the scalability of the algorithms in multi-domain environments. Among all mothods, only our approach and PFL-GAN are able to adapt effectively to this increased complexity. However, our method siguificantly outperforms PFL-GAN, achieving 1.2x to 1.58x higher image generation scores, and outperforms all other approaches by up to 2.5x.
Table 11 presents the classification metrics across the different domains and algorithms. HuSCF-GAN achieves 1% to 5% higher metries than PFL-GAN in most domains, with the exceplion of the FMNIST and NotMNIST domains, where the results are comparable. Nonetheless, HuSCF- GAN achieves up to 50% higher classification metrics than all other algorithms. These results demonstrate both the scalability and consistent effectiveness of our approach in increasingly complex multi-domain settings.
Table 11: Classifier Performance Cour-Domains IID Data
SINEST Datastt
FMNIST Datsost
Accuswcy
Precialon
Recall
Score
FPBL...
Accuracy 1
Procition
Recall
Scoce
PPH
PMO
Sanodl
60.90
57 12.00---0
40:56
6.50%-
40.50
43. 17.17%--
MULGAX Ican0
2017
24 21.55
23 29.3
20.48
+222
156 21- 20..7
41 41.42%:11.15
S4. M4.402211
164152210
GAN Bo
17.07
16,379
9.315-0.57
22.4138 60.46
19.235-0.63
22.41%
MFL-GAN
02 123 07
05.55
45.35%/30.5
0.047
00 00.01220..00
45.56% 96
5,48220.46
Tiore GA
16. 45.0%%--0.34
R5 60.36
85.88%
0.655/-00118 18
R2 R2.3176--00 +0.55
20155-655
KMNISS
NoIMNIET
Accurscy
Preciaton
Recall
PL Scoce
FFR
Accuracy
Precition
Recall
21 Scuee
PPR
MDD GAX
30 303 10.30 10.30
43 15844
23.302
13. 10.05:00000
37 0010 45
40.35 40.55
37.0054066
33.05510.01
6.091005
GAN Routonar 2003
71 20 0:390
3.305-6:36
85-2355-6.62
46.11554666
16:105.000 GG
305
31.:39/21191
ThoCP BAN
70.01 404.65
76.91%.40.84
12.912540.45
75.09/540.66
3.015/40.05
64.007440.00
68.54754-0455
06 66.2475.-0.66
86.35% 0.66
1.305--0.39
6.1.7 Medical Imaging Datasets
To further evaluate the robustness of our algorithm, we introduce non-lID multi-domain scenario designed to reflect a realistic medical imaging use case. In this setting, 100 clients are divided across two distinct domains: 50 clients are assigned data sampled from the BloodMNIST dataset, and the remaining 50 clients from the DermaMNIST datasot. Within each domain, data heterogencity is introduced through non-IID sampling some clients have access to the full set of labels, while 20 clients are missing two labels, 5 clients are missing three labels, and another 5 clients are missing four labels.
This scenario is specifically designed to showcase the applicability of our approach to medical imaging, where privacy preservation is crucial no patient images or labels can be shared and domain separation (e.g., between different imaging types) plays a vital role.
It is evident that our proposod approach consistently outperforms all compoting methods on both BloodMNIST and MNrMTMNIST datasets, as well as across various classification metries. Although PFL-GAN demonstrates competitive performance, it shows limitations when dealing with non-III) data distributions, as illustrated in Figures| 15a and [5b] and reflected in the classification accuracies reported in Table I2 In contrast, our method achieves between 1.2x and 3x higher BloodMNIST and DermaMNIST scores compared to the other algorithms. HuSCF-GAN delivers an improvement. in classifier metrics ranging from 9% to 70% over the remaining approaches.
Table 12: Classifier Performance- - Medical Imaging Datasets
BloodMNNSST Datasst
DermabiNiST Datueet
Accosary:
Precision
Recall
Scote
FPR.
Ascwary 1
Procidion
Recall
Sccen
PPR.
AN
30 00-105441
1956-144
MILIDAN
7 7:40%040000
13 11188-114
12:30
In 61 A1
12.555641 18
8 30 94
10 10-0011-10 A6
12132-1-33
14.17541.51
4.527240.00 09
15:4255443 4-13
107
14. 11--935--1300
16.41544..0
13.175
11 -11--1117
15.
1PP--GAN
01.55
43 407
36.725.3.46
4G
28.237.33.00
0:00
1.00
10 82
15.08
13.379561..1
11.2075.41.0 21
16 10.013..11
H6SCF-GA
17. 17.877
Te. 03-633333334
16. 16.10%
75.02% 141
3.25%/250.00 80
6S1 23..09963:3:10
34 34.7456653.00
35. 13.0866629900
25 28.0896:1.000
6.099Ca83.20 220
22

---

Published in Transactions on Machine Learning Research (01/2026)
HuSCF- GAAN
PFL-GAN Fed. Split GANs
FedGAN
MD-GAN
HFL-GAN
10
9
8
FMNIST Score
MNIST Score
8
3
2
100
200
150
250
Total Number of Epochs
Total Number of Epochs
(b) FMNIST score vs. Training Epochs: HuSCF-
(a) MNIST score vs. Training Epochs: HuSCF-GAN achieves up to 2x higher scores than other approaches.
GAN achieves up to 2x higher scores than other ap- proaches.
10
9
9
NoEMNIST Score
KMNIST Score
7
6
6
3
3
50
100
150
200
250
50
100
150
200
250
Total Number of Epochs
Total Number of Epochs
(c) KMNIST score vs. Training Epochs: HuSCF- GAN achieves up to 2x higher scores than other ap- proaches.
(d) NotMNIST score vs. Training Epoch: HuSCF-
GAN achieves up to 2.1x higher scores than other ap- proaches.
Figure 14: Image Generation Scores Four-Domain IID Data
23

---

Published in Transactions on Machine Learning Research (01/2026)
HuSCF-GAN
PFI-GAN Fed. Split GANs
FedGAN HFL-GAN
MD-GAN
BloodMNIST Score
DermaMNIST Score
150
250
Total Number of Epochs
Total Number of Epochs
(a) BloodMNIST Score vs. Training Epochs: HuSCF-GAN achieves scores that are 1.2x to 3x higher compared to other approaches.
(b) DermaMNIST Score vs. Training Epochs: HuSCF-GAN achieves scores that are 1.33x to 2.2x higher compared to other approaches.
Figure 15: Image Generation Scores
Medical Imaging
6.1.8 Higher Resolution Datasets
Another experimental scenario is designed evaluate the adaptability of our framework on higher-resolution datasets, namely CIFAR10 and SVHN. This setup follows a structure similar that described in Subsubsec- tion 6.1.5 where clients draw data from two distinct domains: 50 clients hold non-lID data sampled from the CIFAR1O dataset, while the remaining 50 clients hold non-IID data from the SVHN dataset. Within each domain, 20 clients have two labels excluded, and another 30 clients have three labels excluded. Furthermore, the dataset sizes vary among clients some possess 600 samples, others 200, and a few as few as 100 samples.
For this scenario, we assess image generation quality using the Fréchet Inception Distance (FID) score, as these higher-resolution RGB datasots are more suitable for FID-based evaluation compared to the other datasets used in this study.
HuSCF-GAN continues to exhibit stable and superior performance. As illustrated in Figures 16a and 16b our method consistently achieves substantially lower FID scores, outperforming all other algorithms with margins ranging from 2x to 70x lower values. Moreover, our approach attains the highest classification performance, as reported Table 13 with improvements ranging from 20% to 45% on CIFAR10 and from 10% to 60% on SVHN compared to all competing methods. These findings highlight the robustness and adaptability of HuSCF-GAN when applied highly heterogeneous, high-resolution datasets.
Table 13: Classifier Performance Higher Resolution Images
Ancurary
Provicion
Rewall
P1 Score
FPR
Ancurney
Presitton
Rovall
Pt Seree
FPR
Bracmi
540 41AN
25.1275.0..5
20 60..000
30. 24.443220.24
43.55
10.3955...35
18.4275.30.35
10. 40.4075.0..3
7.474.0.12
9.395500
Peo 9cin
14.0
23.31%:20.41
23.35
11.241//244
12.89%ca4..42
20.39
P01.
2021
37.00%5...00
20 0..00
30 10.50511..00
37.4175....3
37.51751..00
35.01%.10
6902-00.0
ThoOCP GA
07.8955.0.91
$1.0775..0..0
01.45% 40.00
4.44%
75.1005..0.88
70.5175.0.0
-1.9575-00.0
70.0175.0.9
2.90%
24

---

Published in Transactions on Machine Learning Research (01/2026)
HuSCF-GAN MD-GAN
PFI-GAN Fed. Split GANs
FedGAN HFL-GAN
500
500
450
450
100
100
FID Score
FID Score
250
250
200
200
150
150
100
100
50
50
100
Total Number of Epochs
Total Number of Epochs
(a) CIFAR10 FID Score vs. Training Epochs: HuSCF-GAN GAN achieves FID scores that are 1.8x to 60x lower compared other approaches.
(b) SVHN FID Score vs. Training Epochs: HuSCT-
GAN achieves scores that are 2x to 70x higher and significantly more stable compared to other approaches.
Figure 16: FID Scores Higher Resolution Datasets
6.1.9 Audio Dataset
The final experimental scenario aims to evaluate the adaptability of our framework across different data modalities, specifically audio. To this end, employ the AudioMNIST dataset [eekkr et al. (024)), which consists of spoken digits from zero to nine. This setup follows a similar configuration to that described in Subsubsection 6.1.2 where clients draw data from a single domain. total of 100 clients participate in this experiment, holding non-IID partitions of the AudioMNIST dataset: 40 clients have 2 labels excluded, 10 clients have 3 labels excluded, and another 10 clients have labels excluded.
Since the base model architecture relies on convolutional and deconvolutional layers, using raw audio signals directly would be incompatible. Therefore, each audio file processed using the Librosa McFee et al. (2015) library to compute 128-bin mel-spectrogram,, which was then converted to log-scaled power representation and resized to 28 x 28 pixels. The resulting spectrograms were converted to grayscale format for input to our model architecture.
While the base model capable of generating audio samples, the output quality remains limited due the low input resolution (28x28), which inevitably results in the loss of fine-grained spectral information. Nonetheless, this setup effectively demonstrates the proof of concept for extending our framework to the audio domain.
HuSCF-GAN continues to exhibit stable and superior performance. As reported in Table 14 it consistently outperforms competing approaches with improvements ranging from 1.5% to 13% across all evaluation metrics. These results highlight the robustness and cross- modal adaptability of HuSCF-GAN compared to existing federated generative learning algorithms.
It important note that, due the different data modality, traditional image-based evaluation metrics such Inception Score and FID are not applicable. Instead, audio-specific generation metrics should be considered for more accurate assessment direction for future work.
25

---

Published in Transactions on Machine Learning Research (01/2026)
Table 14: Classificr Performance Audio Experiment
AudIoMNISTT Dataset
Accuracy
Precision
Recall f
F1 Score t
FPR
FodGAN (Rasouli al.
2020
96.67%++-0.45
96.71%+0.445
96.67%
96. 0..47
0.37%++0.16
MD-GAN Hardy et SL
2019
90.29%:t0.75
91.13%:#0.72 72
90.29%:20.75
90. 09.199750075
1.08%:20.26
Fed. Split
GANs Kortoci et al
2022
89.34%%:+00778
90.01%:#0.77 76
89.90%++0.7
88 08.993%=#0799
1.06%+0.200
HFL-GAN
Peich M. 2025
93.62% 62
93. 08.66%.20666 62
93.62%:20 62
93 0.
0.71%+40.21
PFI.-GAN Wijesanghe
2025
85.00%:110.90
71.26% 1.11
85.30%
77 77.07%.11.00
3.78%:10.48
HoSCE-GAN
18.05%++0..0
98.06%-#0.08
98.04%:20.33
98.03% 0.335
0.22%:+0..1
6.2 Latency Comparison
Training latency is critical factor when deploying generative algorithms on underutilized or resource- constrained devices. In this comparison, we evaluate the latency per training iteration specifically, the time required to train a single batch per client.
As shown in Table 15 our approach achieves lower training latency compared to all other benchmark algorithms, with the exception of Federated Split GANs (Kortoçi et al., 2022). which demonstrates comparable performance. This substantial performance difference arises because both PFL-GAN (Wijesinghe et al., 2023) and FedGAN (Rasouli et al.) 2020) train the entire GAN model on each client device. Mcanwhile, HFI-GAN (Petch et al. 2025) exhibits the highest, latency due to its dual-generator structure, where two generators are trained per client effertively doubling the latency compared to FedGAN. This significantly amplifies training time, particularly on resource-constrained devices.
In contrast, MD-GAN (Haddy et al., 2019h trains only the discriminator on the client side, resulting in improved latency relative to PFL-GAN and FedGAN. Notably, both our method and Federated Split GANs dynamically adapt to the computational capabilities of individual clients, achieving optimal latency even in the presence of weaker devices.
While Federated Split GANs achieves comparable latency, it struggles considerably with non-IID data and multi-domain settings, where our method (HuSCT-GAN) demonstrates superior performance. Additionally, although PFL-GAN attains good scores and classification metrics, its latency remains significantly higher compared to HuSCF-GAN, which achieves both high performance and low latency.
These results highlight the effectiveness of our method in utilizing underpowered devices, enabling faster training while preserving strong generative and classification performance.
Table 15: Latency Comparison Across Approaches: HuSCF-GAL achieves the lowest latency, offering up to 58x reduction compared to other methods.
Approach Latency (s)
HuSCF-GAN
PFL-GAN FodGAN
HFL-GAN
MD-GAN
Fed. Split GANs
7.8
251.37
234.6
454.22
47.73
8.68
Table 16 presents the generator and discriminator head and tail layers corresponding to the various device profiles detailed in Table 4 It is important to note that auxiliary layers such as Batch Normalization, activation functions (e.g., ReLU), and label embeddings contribute negligibly to the overall computational cost (in terms of FLOPs) when compared to the primary layers, namcly fully connected layers, convolutional layers, and transposed convolutional layers. Therefore, for clarity and relevance, only these major layers are included in the table. As shown, devices with weaker capabilities such as devices 1& 5-are assigned fewer layers, while more capable devices such device 7 incorporate additional layers within both the generator and discriminator components. A thorough analysis of the computational complexity of HuSCF- -GAN is demonstrated in appendix 6.4.1
26

---

Published in Transactions on Machine Learning Research (01/2026)
Table 16: Client-side layers per device
Device
Generator
Head
Generator Tail
Discriminator Head
Discriminator Tail
Device
FC 256x7x7
ConvT, 3x3,
Conv; 4x4, x2
PC 1 (Sigmoid)
FC 256x7x7
Conv'l, 1xl, s2
Conv, 4x4, 82
Device
Con'T, 4x4,
ConvTr 3x3,
Conv, 4x4, 62
(Sigmoid)
FC 256x7x7
Convi. 1x4,
Coav, 4x1, 82
Conv, 4x4, 82
ConvT, 4x4, 62
ConvTT 3x3, s1
Conv, 4x4, 62
FC 1 (Sigmoid) Conv, 4x4,
Device
ConvT, 4x4, s2
256x7x7
ConvT, 3x3,
Conv'T,
Conv, 4x4, 62
PC (Sigmoid)
Conv, 4x4, x2
Device
FC x
ConvT, 3x3,
FC 1 (Sigmold)
Conv, 4x4, x2
Device
FC 266x7x7
ConvT, 4x4, #2
Conv, 4x4, 62
FC 1 (Sigmold)
ConvT, 1x4,
ConvTT, 3x3,
Conv, 4x1, 62
FC 250x7x7
Conv': 4x4,
Conv, 4x4, 62
Conv, 4x4, s2 FC 1 (Sigmold)
Device
ConvT, 1x4, 82
Conv T, 3x3, s1
Conv, 4x1, 62
6.3 Comparison Between Label Distribution- Based and Activation- Baaaadd KLD for FL Weights Calculation
This section provides a detailed analysis of the KLD Boulback-Leibbeee Divergence) computation by comparing two approaches: the activation-basee KLD introduced in this work MUSCF-GGNN, and the label distribution- based KLD approach (Guerraoui et al. 2020), which requires clients to share label information with the server thereby compromising data privacy.
For this evaluation, we focus on the sccond test case scenario described in Subsubscction 6.1.2 where the dalaset originates from a single domain and follows a Non-IID distribution. This setup deliberately chosen to focus on the effect the KLD component, ensuring that the evaluation of KLD not affected by the performance variations introducod by multi-domain scttings.
As shown in Figure 17 both approaches converge to the same MNIST Score similar rate. Furthermore, Table 17 presents classifier performance metrics for both methods, which nearly identical. These results demonstrate that the proposed activation-based KLD not only preserves client privacy by avoiding label sharing but also matches the performance of the label-based alternative-thenee offering more privacy- presevcvgeeevvingggg solution without sacrificing effectiveness.
HuSCF-GAN + Activations Based KLD HuSCF-GAN + Label Basod KLD
9
MNIST Score
3
0
50
100
150
200
250
Total Number of Epochs
Figure 17: MNIST Score Training Epochs Single-Domain Domain Non-IID Data
27

---

Published in Transactions on Machine Learning Research (01/2026)
Table 17: KLD Comparison Singlo-Domain Non-IID Data
MNIST Dataset
Accuracy
Precision t
Recall
F1 Score
FPR
HuSCF-GAN
Label-Based KLD
97.2%+00.3
07.19%++0.32
07.19%+0.32
97.17%+
0.31%++0.11 0.31%:t:0:11
HuSCE-GAN + Activation-Bsaed KLD
97.17%:tt..3
97.21%.2..3.
97.18%::0.32
97. 97.13%:t..33
6.4 Complexity Analysis
In this subsection, we discuss the computational (time) and space complexity of HuSCF-GAN in comparison with FedGAN. All variables and notations used are listed in table 18
Table 18: Table of Notations and Variables
Symbol
Description
BG AGr
Number of parameters in the head and tail of the generator for client kt Number of parameters in the head and tail of the discriminator for client k Number of parameters in the i-th server-side layer of the generator and discriminator Total number of parameters for the full server-side generator and discriminator segments Total number of parameters in the full generator and discriminator, respectively Number of clients per i-th layer of the generator and discriminator server segments Total number of clients
DDH RDra
BGa3 TDDs,
nG WDs
nG, RD
NG.1 ND.
N
M
Number of federation rounds Total number of iterations Batch size
AGu AG
Activation size per sample for the head and tail of the generator for client h Aclivation size per sample for the head and tail of the discrininator for client k Activation memory for the i-th server-side layer of the generator and discriminator Total activation size for the full server-side generator and discriminator segments Total activation size for the full generator and discriminator
ADa, Apr.k
AGg, Apg.
AGs: ADs
Ag, Ap
6.4.1 Computational Complexity
HuSCT-GAN consists of both client-side and server-side components. The model partitioned such that each client computes the head and tail segments of the generator and discriminator denoted GH, GT, DH, and Dy-while the server handles the shared segments Gs and Ds, in addition to aggregation. We compare the computational complexity of HuSCT-GAN with FedGAN, which places the entire model on the client side.
Client-Side Computational Complexity
Each client executes local computations on its assigned model segments. Let I denote the total number of training iterations and the batch size. Table 19 presents the client-side complexity for both methods. HuSCF-GAN reduces per-client computation by processing only partial model segments, an advantage for resource-limited devices where ofloaddigg computation the server enhances scalability.
It is important to note that ng nD >> A.HH AGT. + DDa, + Dr., which means that the load on the client-side in our approach is less, approach puts most of the load on the server.
Server-Side Compulational Complerity
Table 20 summarizes the server-side complexity. While FedGAN's server only performs aggregation, HuSCF- GAN's server also executes part of the forward and backward computations. Although this increases server workload (because it puts bulk of the generator and discriminator calculations the server besides the
28

---

Published in Transactions on Machine Learning Research (01/2026)
Table 19: Client-side computational complexity comparison.
Method
Client-Side Computational Complexity
HuSCF-GAN
Ib (nGGn nGT, + DDDA + DDD
Client-side segments training iterations
FedGAN
o
lnn + nD)
Client models training iterations/
aggregation), it substantially reduces client burden (the client longer need to do the full model calculations), leveraging the server's typically greater computational capacity to improve overall efficiency and scalability.
Table 20: Server-side computational complexity comparison.
Method
Server-Side Computational Complexity
HuSCF-GAN
O
Ib No.moss + ND.
+ MN max N.G. + max P.G max DD
max DD
Server-side training iterations
Client-side foderated aggrogation
FedGAN
MN (ng + nD)
Client models federated aggregation/
6.4.2 Space Complexity
We now analyze the memory requirements of HuSCF-GAN compared to FedGAN, considering parameter storage and intermediate aclivations.
Client-Side Space Complenity
Each client stores its local model segments (Gn, GT, Du, Dr). The resulting space complexity is shown in Table 21 HuSCF-GAN lowers client memory consumption by limiting storage to local segments in contrary with FedGAN where clients store the full models. It is important to note AG + Ap >> AGua + AGr, +
ADRa + AArx
Table 21: Client-side space complexity comparison.
Method
Client-Side Space Complexity
HuSCF-GAN
nG + nGr. #nD. + +DDra + b(Aam. + AGra + ADW + ADr.)
Parameters of client-side segments
Activations of client-side segments
FedGAN
nGG + np
b(Ag Ap)
Parameters of client models
Activations of client models
Server-Side Space Complerity
The server stores parameters and activations for Gs and Dy and retains the maximum client-side parameters during aggregation. The overall complexity is shown in Table 22
The memory footprint the server in approach is larger than FedGAN, because approach assumes that the server is more capable and can assist the clients in their computations.
29

---

Published in Transactions on Machine Learning Research (01/2026)
Table 22: Server-side space complexity comparison.
Method HuSCF-GAN
Server-Side Space Complexity
o(
Ensor + noe.)
Σ
Aoe. + Npg)
maxi (GG + DGG + Fipu + 1o
Activations client-side segments aggregation
Parameters of serversiiee segments
Activations of server-side segnennts
FedGAN
Paramaters of client models for aggregation
HuSCF-GAA reduces the memory footprint clients while slightly increasing memory usage due to shared segment computation and aggregation. This tradc-off enhances scalability and system efficiency in federated learning environments.
7 Discussion
7.1 Limitations
In regards to our approach, several limitations should be acknowledged.
Centralized dependency: Although HuSCF-GAN leverages heterogeneous and underutilized devices, it does not operate in fully decentralized manner. The framework still relies on central server to support these devices and to handle critical tasks such as clustering, foderation, and the execution of genetic algorithms. The server also responsible for performing the forward and backward pass computations for the server-side layers.
Privacy vulnerabilities: While our approach avoids sharing raw data or labels, it may still be vulnerable to certain privacy-related threats. In particular, the system could be susceptible to attacks such data reconstruction and label inference, where adversarics attempt extract sensitive information from shared gradients or intermediale representations.
System complexity and scalability: Our approach integrates multiple components components-iineudingg
a Genetic Algorithm, Federated Learning, U-shaped Split Learning. Kullback-Leibler Divergence (KLD) calculations, and clustering- which collectively introduce additional complexity. For exam- ple, selecting the optimal cut point can create computational overhead, particularly in large-scale environments where many device profiles may introduce variability and unwanted delays.
Tuning the hyperparameters for these components across a large number of devices be challenging. Such tuning not only increases computational burden but may also prolong convergence times, especially as the network scales to thousands of devices. These factors represent added complexity that can affect the scalability and responsiveness of the system.
Hyperparameter tuning:
Recognizing these limitations is essential for guiding future improvements to enhance both the robustness and security of HuSCF-GAN,
7.2 Possible Risks & Mitigation Strategies
While our work enables distributed GAN training in heterogeneous, multi-domain environments under data-sharing constraints using split federated learning, it is important to recognize that such systems may be vulnerable to various types of attacks (Shabbir et al. 2025). In this subsection, we discuss potential threats and outline strategies to mitigate them.
One critical category of threats data reconstruction attacks, where an adversary attempts recover private training data by exploiting shared gradients or activations exchanged between end devices and the server. This risk is particularly serious because preserving data privacy is central goal of our approach. Examples of such attacks include:
30

---

Published in Transactions on Machine Learning Research (01/2026)
Feature Space Hijacking Attacks: A malicious server manipulates feature representations to align with a target feature space that it knows how to invert (Pasquini et al. 2021 Gawron & Stubbings 2022
Model Inversion Attacks: An honest-but-curious server records smashed activations and uses optimization techniques generative models to reconstruct approximations of clients' raw inputs Er dogan et al. 2022
Feature Reconstruction Attacks: Adversaries allempl recover input data directly from intermediate feature representations (Xu et al. 2024 Ye al. 2024).
GAN-based Attacks in Split Learning: An adversary trains generator to produce fake inputs whose feature reprosentations or gradients closely mimic those observed during training (Zng et al. 2025).
Another class of threats involves label inference attacks, where adversaries seek to infer sensitive label information from client updates or intermediate activations. Examples include:
Gradient-based Label Inference: Correlations between gradient updates and labels are exploited
to extract hidden label information (Liu et al. 2024 Xie et al. 2023 Zhao et al. 2024 Bai et al.
2023 Kariyappa & Qureshi 2023
Smashed Data-based Label Inference: Relationships between intermediate activations and label distributions are leveraged to infer labels, for instance through clustering distance-based
methods [Zuu et al. 2023 Liu et al. 2024).
Other possible threats include adversarial attacks and model poisoning attacks (Wu et al. 2024 He et al.
2024 Gamal et al. 2023 which can disrupt model performance or corrupt its learned representations.
To address these risks, several mitigation strategies can be applied strengthen the security and privacy of framework:
Employing homomorphic encryption to protect data during transmission and computation Yi et al.
2014 Kokaj & Mollakuqe 2025 Khan et al. 2023
Applying differential privacy techniques perturb data or gradients, thereby limiting information leakage (work 2006
Pham el. al. 2024
Using function secret sharing to securely split and process sensitive data Khan et al. 2024
Introducing randomized activations or layers make feature representations less pre- dictable (Mao al.
2023
Implementing detection mechanisms for weight or gradient manipulation and anomaly detec- tion Fu et al. 2023 Erdogan et al. 2022 Erdogan et al. 2024
Incorporating these mitigation stratogics would further enhance the robustness and capabilities of proposed approach.
7.3 Applicability to Other Generative Models
The HuSCF-GAN framework can be extended to a wide range of other generative models, including transformers, diffusion models, and large language models (LLMs). The core methodology remains the same: both the input and output of the model well as any labels, if applicable are kept strictly on the client side to preserve data privacy, while distributing the computational load different clients according to their capabilities.
31

---

Published in Transactions on Machine Learning Research (01/2026)
The primary adjustment lies in the number of cut points required. GANs, with their dual-network architecture, necessitate four cut points. In contrast, architectures with a single network, such as encoder-only networks (e.g BERT (Devlin et al.) 2019) ) or decoder-only networks (e.g GPT (Radford et al. 2018)), )) would only require two cut points one near the input and another near the output to keep the data and the labels on the client- However, the framework should allow for dynamic number of cutpoints in the future. In this sctup, the initial portion and final portion of the model remain data and generated outputs (e.g., predictions or text) never leave the client side. However, our framework would allow for a dynamic number of cutpoints according to the application needs, and devices complexity.
the client devices, ensuring that input
Applying this approach to LLMs could enable training on vast amounts of text data stored on undorutilized personal devices, such as smartphones, while simultancously taking advantage of their unused computational resources. Furthermore, the clustering component of our framework could group different LLM instances by domain for example, medical texts, geographic data, or general knowledge allowing for the creation of specialized models tailored to specific fields.
Similar to GANs in our approach, these models would share portions of their intermediate parameters, enabling them to learn collaboratively while still specializing in their respective domains. The same principles can also be exlended to diffusion models (Ho et al. 2020), vision transformers (Dosovitskiy et al. 2020), and other modern generative architectures.
7.4 Illustrative Use Case
With the rapid proliferation of Al-powered assistants and copilots (Stratton 2024) across domains- from personal and domestic helpers to industrial, medical, and autonomous systems there is a growing need for these assistants (copilots) to perceive, understand, and generate visual content real time. These systems are increasingly equipped with sensing and vision capabilities, continuously interacting with their environments and users.
To illustrate the practical impact of our proposed HuSCF-GAN framework, we consider a use case involving a network of such intelligent assistants or copilots equipped with vision systems that continuously capture and generate image data. These assistants operate in distinct environments sushassssssshhhssseeesse as domestic, industrial, or outdoor settings leading to naturally diverse and highly non-llI) image distributions spanning multiple domains. Beyond interpreting visual information, they must also generate synthetic images for purposes such as environment simulation, object recognition enhancement, visual communication with humans, training visual tasks involving human collaboration. In this context, MASCF--GAN enables collaborative training among assistants without requiring centralized data sharing, allowing each assistant to learn from collective visual knowledge while keeping its local image data and labels private. By utilizing underused computational resources on the assistants themselves, the framework minimizes infrastructure costs of relying on a central server. It dynamically adjusts participation and update frequencies according to each assistant's computational capacity and data characteristics, ensuring balanced and stable model convergence. Furthermore, its domain- clustering mechanism groups assistants based on visual domain similarities for instance, indoor versus outdoor imagery- while still maintaining shared global learning to capture cross-domain visual patterns. Through this approach, HuSCF-GAN could provide privacy--reserving, resource-effcceetl, and scalable solution for collaborative image generation and understanding across heterogeneous assistants, ultimately improving their visual pereeption and generative capabilitics in real-world environments. We believe that HuSCF-GAN is a good fit in this example or other examples proposed by the research community
8 Conclusion & Future Work
Centralized generative models-sooe as traditional Generative Adversarial Networks
several critical limitations when applied in real-world, distributed environments. One major challenge is data diversity: in practice, most client devices retain their data locally due to privacy concerns, leading to limited access to the full distribution of data and reducing the generalization ability of centralized models. Another issue is the inefficient use of computational resources, where many edge devices, IoT devices, and wearables remain underutilized while powerful centralized servers perform the bulk of training.
32

---

Published in Transactions on Machine Learning Research (01/2026)
To address these limitations, distributed Generative AI training has emerged as promising paradigm. However, this approach introduces its own set of challenges, such as data heterogeneity (clients possess non-IID data that may differ significantly in distribution), device heterogencity (clients differ in computational capabilities and nelwork speeds), and domain disparity (client dalasets may originate from entirely different. domains or modalities). Moreover, the presence of strict data sharing constraints further complicates the design of collaborative learning systems.
In this paper, we propose HuSCF-GAN, novel Helerogeneous U-Shaped Clustered Pederaled Generalive Al approach- implemented using a conditional GAN (cGAN) as a proof of concept- that systematically addressos key challonges in federated learning with generative models. Our method partitions the model architecture such that different components are trained across clients and the server, enabling flexible model splitting based on client capabilities and communication bandwidth. By adapting to both data and system heterogeneity, HuSCF-GAT significantly improves training efficiency and model performance.
Through extensive experiments, we demonstrate that HuSCF-GAN outperforms state-of-the-art benchmarks across multiple datasets and experimental settings. Tt achieves superior classification performance- across metrics such as Accuracy, Precision, Recall, F1 Score, and False Positive Rate with an average improvement of 10%, and up to a 60% gain in multi-domain, non-IID environments. In terms of image generation quality, HuSCF-GL GANN achieves between 1.1x and 3x improvement in generation scores for the MNIST family, and between 2x and 70x lower FID scores for higher resolution datascts. Furthermore, substantially roduces latency in heterogeneous and resource-constrainee environments, achieving least 5x and up to 58x reduction compared to existing benchmarks.
Potential dircctions for future rescarch include the following:
Distributing the generative model across multiple edge devices without relying on central server. This would involve selecting dynamic number of cut points based the mumber of available devices, rather than using fixed number (four, in our case). Such an approach enables full reliance on underutilized low-power devices, eliminating the need for the centralized infrastructure avoiding its costs.
Optimizing cut point selection based on factors such energy consumption, data quality and quantity at each node, and the expected battery lifetime of the devices.
Make dynamic cut selection throughout training to adapt to dynamically changing devices capabilities and configurations.
Incorporating peeaccc-reeeriing techniques such as Differential Privacy or Homomorphie Encryption to enhance data security during training.
Extending the approach other generative architectures, such as diffusion models, transformers, or large language models (LLMs), evaluate its generalizability.
Evaluating the proposed system on a physical testbed rather than relying solely on simulation, to validate performance under real-world conditions.
Evaluation the framework on more complex dataset (Higher resolution images) and more diverse modalities (e.g Time-series, text, and 3D objects)
Investigating alternative generation evaluation metrics tailored to various data modalities
Broader Impact Statement
Our work on HuSCF-GAN advances distributed generative AI by enabling deployment across heterogencous devices with varying computational capabilities, diverse data distributions, and multiple domains. leverages idle resources and can access data constrained by privacy or sharing limitations.
However, this approach carries potential risks, including the possibility that shared activations gradients could be exploited to reconstruct sensitive input data. We emphasize that careful deployment is essential and
33

---

Published in Transactions on Machine Learning Research (01/2026)
strongly recommend incorporating additional function secret sharing, differential privacy, and zero-knowledge proofs (ZKPs), to mitigate these risks and ensure responsible use of the technology.
techniques, such as homomorphic encryption,
References
Sa'dia Abul-Fazl, Rasim Dina, and Hafez Fairuza. Diffusion models at scale: Techniques, applications, and challenges. Preprints, February 2025. doi: 04220444proprmm22255000000. URL https: http://doo.or///// 20044/preprrims222222..0.00 0029.002...... vv
Hossam Amer, Joe Osborne, Michael Zaki, and Mohamed Afify. Ou-device emoji classifier trained with gpt-based data augmentation for a mobile keyboard. arXiv preprint arXiv:2411.0500 2024.
Hossam Amer, Maryam Dialamch, Hossein Rajabzadeh, Walid Ahmed, Weiwei Zhang, and Yang Liu. Flop- efficient training: Early stopping based on test-time compute awareness. arXiv preprint or Xiv:2601.01332, 2026.
Vijie Bai, Yanjiao Chen, Hanlei Zhang, Wenyuan Xu, Haiqin Weng, and Dou Goodman. (VILLAIN): Backdoor attacks against vertical split learning. In 32nd USENIX Security Sympostum (USENIX Security 23), pp. 2743 2760, 2023.
Sören Bocker, Johanna Viclhaben, Marcel Ackermann, Klaus-Robert Müller, Sobastian Lapuschkin, and Wojciech Samek. Audiomnist: Exploring explainable artificial intelligence for audio analysis on a simple benchmark. Journal of the Franklin Institute, 361(1):418 428, 2024.
Yaroslav Bulatov. notmnist dataset. html, 2011. Accessed: 2025-05-21.
Xingjian Cao, Gang Sun, Hongfang Yu, and Mohsen Guizani. Perfed-gan: Personalized federated learning via generative adversarial networks. IEEE Internet of Things Journal, 10(5):3749 07662, 2022.
Diletta Chiaro, Edoardo Prezioso, Michele lanni, and Fabio Giampaolo. Fl-enhance: A federated learning framework for balancing non-iid data with augmented and shared compressed samples. Information Fusion, 98:101836, 2023.
Tarin Clanuwat, Mikel Bober-Trizar, Asanobu Kitamoto, Alex Lamb, Kazuaki Yamamoto, and David Ha. Deep learning for classical japanese literature. arXiv preprint 111:1112.01118, 2018
Jacob Devlin, Ming-Wes Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 conference of the North Americon chapter of the associalion for compulational linguisties: human language lechnologies, volume 1 (long and short papers), pp. 4171-4186, 2019.
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesníkov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint ar 20v: 11929, 2020.
Cynthia Dwork. Differential privacy. In International colloquium on automata, languages, and programming, pp. 12. Springer, 2006.
Ebba Ekblom, Edvin Listo Zec, and Olof Mogren. Effgan: Ensembles of fine-tuned federated gans. In 2022 IEFE International Conference on Big Data (Big Data), pp. 884-892. IEEE, 2022.
Ege Erdogan, Alptekin Küpçü, and A Ercument Cicek. Splitguard: Detecting and mitigating training- hijacking attacks in split learning, In Proceedings of the 21st Workshop on Privacy in the Electronic Society, pp. 125-137, 2022.
Ege Erdoğan, Alptekin Küpçü, and A Ercüment Çişek. Unsplit: Data-oblivious model inversion, model stealing, and label inference attacks against split learning. In Proceedings of the 21st Workshop on Privacy in the Electronic Society, pp. 115-124, 2022.
34

---

Published in Transactions on Machine Learning Research (01/2026)
Ege Erdogan, Unat Teksen, M Salih Çeliktenyildı, Alptekin Küpçü, and A Ercüment Çigek. Splitout: Out- of-the-box training-hijakknng detection in split learning via outlier detection. In International Conference on Cryptology and Network Security, pp. 118-142. Springer, 2024.
Chenyou Fan and Ping Liu. Federated generative adversarial learning. In Pattern Recognition and Computer Vision: Third Chinese Conference, PRCV 2020, Nanjing, China, October 16-18, 2020, Proceedings, Part III 3, pp. 3-15. Springer, 2020.
Xin Fan, Yue Wang, Weishan Zhang, Yingshu Li, Zhipeng Cai, and Zhi Tian. Ganfed: Gan-based federated learning with non-iid datasets in edge iots. In ICC 2024-IERR International Conference on Commanicalions, pp. 5443 5448. IEEE, 2024.
Jiayun Fu, Xiaojing Ma, Bin B Zhu, Pingyi Hu, Ruixin Zhao, Yaru Jia, Peng Xu, Hai Jin, and Dongmei Zhang. Focusing on pinocchio's nose: A gradients scrutinizer to thwart split-learning hijacking attacks using intrinsic attributes. In NDSS, 2023.
Karim Gamal, Ahmed Gaber, and Hossam Amer. Federated learning based multilingual emoji prediction in clean and attack scenarios. arXiv preprint arXiv:2304.01000 0100, 2023.
Grzegorz Gawron and Philip Stubbings. Feature space hijacking attacks against differentially private split learning. arXiv preprint orXiv:2201.0401 2022.
Ian Goodfellow, Jean Songet-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. Communications of the ACM, 63(11):
139-144, 2020.
Rachid Guerraoui, Arsany Guirguis, Anne-Marie Kermarrec, and Erwan Le Merrer. Fegan: Scaling distributed gans. In Proceedings of the 21st International Middleware Conference, pp. 193-206, 2020.
Yasaman Haghbin, Mohammad Hossein Badiei, Nguyen H Tran, and Md Jalil Piran. Resilient federated adversarial learning with auxiliary-classife gans and probabilistic synthesis for heterogencous environments. IEEE Trunsactions on Network and Service Management, 2025.
Corentin Hardy, Erwan Le Merrer, and Bruno Sericola. Md-gan: dilttidiisrrmminttor generative adversarial
networks for distributed datasets. In 2019 IEEE international parallel and distributed processing symposium (IPDPS), pp. 866 877. IEEE, 2019.
Yunxiao He, Chunqiang Hu, Yuwen Pu, Jiahao Chen, and Xingwang Li. Advusl: Targeted adversarial attack against u-shaped split learning. In 2024 IEEE 21st International Conference on Mobile Ad-Hoc and Smart Systems (MASS), pp. 357-363. IEEE, 2024.
Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by two time-scale update rule converge to local nash equilibrium. Advances in neural information processing systems, 30, 2017.
Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advonces in newral information processing systems, 33:6840 6851, 2020.
Bharat Jain and W Wilfred Godfrey. Multi-generator md-gan with reset discriminator: framework to handle non-iid data. In International Conference on Computer Vision and Image Processing, pp. 289-303. Springer, 2022.
Sanjay Kariyappa and Moinuddin K Qureshi. Exploit: Extracting private labels in split learning. In 2023 IEEE conference on secure and trustworthy machine learning (SaTML) pp. 165-175. IEFE, 2023.
Anirudh Kasturi and Chittaranjan Hota. Osgan: One-shot distributed learning using generative adversarial networks. The Journal of Supercomputing, 13112) 2023.
Tanveer Khan, Khoa Nguyen, and Antonis Michalas. Split ways: prrivacyprreeeviin training of encrypted data using split learning, arXiv preprint crXio:2301.08775 2023.
35

---

Published in Transactions on Machine Learning Research (01/2026)
Tanveer Khan, Mindaugas Budzys, and Antonis Michalas. Make split, not hijack: preventing feature-space hijacking attacks in split. learning. In Proceedings of the 29th ACM Symposium on Access Control Models and Technologies, pp. 19-30, 2024.
Agon Kokaj and Elissa Mollakuqe. Mathematical proposal for sccuring split learning using homomorphic eneryplion and zero-knowledge proofs. Applied Sciences, (5(6):2913, 2025.
Pranvera Kortoçi, Yilei Liang, Pengyuan Zhou, Lik- Lee, Abbas Mehrabi, Pan Hui, Sasu Tarkoma, and Jon Crowcroft. Federated split gans. In Proceedings of the 1st ACM workshop on data privacy and federated learning technologies for mobile edge network, pp. 25 30, 2022.
Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. (2009), 2009.
Oran Lang, Yossi Gandelsman, Michal Yarom, Yoav Wald, Gal Elidan, Avinatan Hassidim, William T Freeman, Phillip Isola, Amir Globerson, Michal Trani, et al. Explaining in style: training gan to explain classifier in stylespace. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 693-702, 2021.
Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278 22,4, 1998.
Wei Li, Jinlin Chen, Zhenyu Wang, Zhidong Shen, Chao Ma, and Xiaohui Cui. Ift ga-g Improved federated learning generative adversarial network with maximun mean discrepancy model aggregation. IEEE Transactions Neural Networks and Learning Systems, 34(12):10502-10515 2022.
Willone Lim, Kelvin Sheng Chek Yong, Bee Theng Lau, and Colin Choon Lin Tan. Future of generative adversarial networks (gan) for anomaly detection in network security: A review. Compulers & Securily, 139:103733, 2024.
Junlin Liu, Xinchen Lyu, Qimei Cui, and Xiaofeng Tao. Similarity- label inference attack against training and inference of split learning. IEEE Transactions on Information Forensics and Security, 19: 1881-2895, 2024.
Zhuoran Ma, Yang Liu, Yinbin Miao, Guowen Xu, Ximeng Liu, Jianfeng Ma, and Robert H Deng. Flgan: Gan-based unbiased federated learning under non-iid settings. IEEE Transactions on Knowledge and Data Engineering, 36( (6(4):1566-158) 1581, 2023.
Paul Joe Maliakel, Shashikant Olager, and Ivona Brandic. Fligan: Enhancing federated learning with incomplete data using gan. In Proceedings of the 7th International Workshop on Edge Systems, Analytics and Networking, pp. 1-6, 2024.
Laura Manduchi, Kushagra Pandey, Clara Meister, Robert Bamler, Ryan Cotterell, Sina Däubener, Sophie Fellenz, Asja Fischer, Thomas Gärtner, Matthias Kirchler, et al. On the challenges and opportunities in generative ai. Xiv preprint arXiv:2403.0000 00025, 2024.
Yunlong Mao, Zexi Xin, Zhenyu Lí, Jue Hong, Qingyou Vang, and Sheng Zhong. Secure split learning against. property inference, data reconstruction, and feature space hijacking attacks. In European Symposium on Research in Computer Securily, pp. 23 43. Springer, 2023.
Brian McFee, Colin Raffel, Dawen Liang, Daniel PW Ellis, Matt McVicar, Eric Battenberg, and Oriol Nieto. librosa: Audio and music signal analysis in python. SciPy, 2015:18 24, 2015.
Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication- efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics, pp. 1273-1282, PMLR, 2017.
Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint /1t:1111111111 2014.
36

---

Published in Transactions on Machine Learning Research (01/2026)
Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Baolin Wu, Andrew Y Ng, et al. Reading digits in natural images with unsupervised feature learning. In N7PS workshop on deep learning and unsupercised feature learning, volume 2011, pp. 7. Granada, 2011.
OpenAl and Stanford HAL Ai and compute. http:///opeaaal.com//eeeeardaaaa Accessod: 2025-06-20.
2023.
Dario Pasquini, Giuseppe Ateniese, and Massimo Bernaschi. Unlcashing the tiger: Inference attacks on split learning. In Proceedings of the 2021 ACM SIGSAC conference on computer and commuunicalions securily, pp. 2113 2129,, 2021.
A Paszke. Pytorch: An imperative style, high-performance deep learning library. ar preprinl 1rXiv:1912.01100 2019.
Lewis Petch, Ahmed Moustafa, Xinhui Ma, and Mohammad Yasser. Hfl-gan: scalable hierarchical federated lcarning gan for high quantity heterogencous clients. Applied Intelligence, 55(2):170, 2025.
Ngoc Duy Pham, Khoa T Phan, and Naveen Chilamkurti. Enhancing accuracy-privacy trade-off in differentially private split learning. IEEE Transactions Emerying Topics in Compulational Indelligence, 2024.
Yuyan Quan, Songtao Guo, and Dewen Qiao. Refl-gan: Resource-constrained federated learning with generative adversarial networks. In 2024 27th International Conference on Computer Supported Cooperative Work in Design (CSCWD), pp. 513 518. TEEE, 2024a.
Yuyan Quan, Songtao Guo, Dewen Qiao, and Mingyan Li. Aft-gan: adaptive federated learning for generative adversarial network with resource constraints. CCF Transactions on Percasive Computing and Interaction, 6(1):1-17, 2024b.
Alec Radford, Karthik Narasimhan, Tim Salimans, llya Sutskever, et al. Improving language understanding by generative pre-training. 2018.
Mohammad Rasouli, Tao Sun, and Ram Rajagopal. Fedgan: Federated generative adversarial networks for distributed dala. Xiv preprint urXim:2006.0720 2020.
Tim Salimans, Ian Goodfellow, Wojeiech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. Advances in neural information processing systems, 29, 2016.
Eric Samikwa, Antonio Di Maio, and Torsten Braun. Díl:
Dynamic federated split. learning in heterogeneous iot. IEEE transactions on machine learning in communications and networking, 2024.
Aqsa Shabbir, Halil ibrahim Kanpak, Alptekin Küpçü, and Sinem Sav. A taxonomy of attacks and defenses in split learning. arXiv preprint ar arXi::2505.058 2025.
Atif Ahmed Showrov, Md Tarek Aziz, Hadiur Rahman Nabil, Jamin Rahman Jim, Md Mohsin Kabir, MF Mridha, Nobuyoshi Asai, and Jungpil Shin. Generative adversarial networks (gans) in medical imaging: advancements, applications and challenges. IEEE Access, 2024.
Jess Stratton. An introduction to microsoft copilot. In Copilot for Microsoft 365: Harness the Power of Generative AI in the Microsoft Apps You Use Every Day, pp. 19 35. Springer, 2024.
Yunrui Sun, Gang Hu, Yinglei Teng, and Dunbo Cai. Split federated learning over heterogeneous edge devices: Algorithm and optimization. In 2025 IEFE Wireless Communications and Networking Conference (WCNC), pp. 01 06. IEEE, 2025.
Chandra Thapa, Pathum Chamikara Mahawaga Arachchige, Scyit Camtepe, and Lichao Sun. Splitfed: When federated learning meets split learning. In Proceedings of the AAAI conference on artificial intelligence, volume 36, pp. 8485 8493, 2022.
Praneeth Vepakomma, Otkrist Gupta, Tristan Swedish, and Ramesh Raskar. Split learning for health: Distributed deep learning without sharing raw patient data, arXiv preprint arXio:1812.008: 2018.
37

---

Published in Transactions on Machine Learning Research (01/2026)
Achintha Wijesinghe, Songyang Zhang, and Zhi Ding. Pft-gan: when client heterogeneity meets generative models in personalized federated learning. Xiv preprint arXim:2308. 1xX4:2308.12444 2023.
Achintha Wijesinghe, Songyang Zhang, and Zhi Ding. Ps-fedgan: An efficient federated learning framework with strong data privacy. IEEE Internet of Things Journal, 2024a.
Achintha Wijesinghe, Songyang Zhang, Siyu Qi, and Zhi Ding, Ufed-gan: Secure federated learning over wireless scnsor networks with unlabeled data. In 2024 IEEE International Conference on Communications Workshops (ICC Workshops), pp. 1048-1053. IEEE, 2024b.
Nengwu Wu, Wenjie Zhao, Yuxiang Chen, Jiahong Xiao, Jin Wang, Wei Liang, Kuan- Ching Li, and Nitin Sukhija. Hfsl:: heterogeneity split federated learning based on client computing capabilities. The Journal of Supercomputing, (1(1):1- 2025.
Xiaodong Wu, Henry Yuan, Xiangman Li, Jianbing Ni, and Rongxing Lu. Evaluating security and robustness for split federated learning against poisoning attacks. IEEE Tronsactions on Information Forensics and Security, 2024.
Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv: 1oXii:170800P1 077407747, 2017.
Shangyu Xie, Xin Yang, Yuanshun Yao, Tianyi Liu, Taiqing Wang, and Jiankai Sun. Label inference attack against split learning under regression setting. arXiv preprint Xxx:22011007284, 2023.
Xiaoyang Xu, Mengda Yang, Wenzhe Yi, Ziang Li, Juan Wang, Hongxin Hu, Yong Zhuang, and Yaxin Liu. A stealthy wrongdoer: Feature-oriented reconstruction attack against split learning. In Proceedings of the IEFE/CVI conference on computer vision and pattern recognition, pp. (2130-12139) 2024.
Jiancheng Yang, Rui Shi, and Bingbing Ni. Medmnist classification decathlon: A lightweight automl benchmark for medical image analysis. In IEEE 18th International Symposium on Biomedical Imaging (ISBI), pp. 191-195, 2021.
Peng Ye, Zhifeng Jiang, Wei Wang. Bo Li, and Baochun Li. Feature reconstruction attacks and counterneasures of dnn training in vertical federated learning. IEEE Transactions on Dependable and Secure Computing, 2024.
Xun Yi, Russell Paulet, and Elisa Bertino. Homomorphic encryption. In Homomorphic encryption and applications, pp. 27-46. Springer, 2014.
Bo Zeng, Sida Luo, Fangchao Yu, Geying Yang, Kai Zhao, and Lina Wang. Gan-based data reconstruction attacks in split learning. Neural Networks, 185:107150, 2025.
Jiaxin Zhang, Liang Zhao, Keping Yu, Geyong Min, Ahmed Y Al-Dubai, and Albert Y Zomaya. A novel federated learning scheme for generative adversarial networks. IEEE Transactions on Mobile Computing, 23(5):3633-300 36443,33694440 2023.
Yikai Zhang, Hui Qu, Qi Chang, Huidong Liu, Dimitris Metaxas, and Chao Chen. Training federated gans with theoretical guarantees: A universal aggregation approach. arXiv preprint 2xx::22022.4655, 2021.
Kai Zhao, Xiaowei Chuo, Faugchao Yu, Bo Zeng, Zhi Pang, and Lina Wang. Splitaum: Auxiliary model-based label inference attack against split learning. IEEE Transactions on Network and Service Management, 2024.
Peng Zhao, Shaocong Guo, Yanan Li, Shusen Yang, and Xuebin Ren. Fedgen: Personalized federated learning with data generation for enhanced model customization and class imbalance. Future Generation Computer Systems, 164:107595, 2025.
Zilong Zhao, Robert Birke, Aditya Kunar, and Lydia Y Chen. Fed-tgan: Federated learning framework for synthesizing tabular data, arXiv preprint 2r0 2021.
38

---

Published in Transactions on Machine Learning Research (01/2026)
Guangyu Zhu, Yiqin Deng, Xianhao Chen, Haixia Zhang, Yuguang Fang, and Tan F Wong. Esfl: Efficient split federated learning over resource-consttaamed heterogeneous wireless devices. TEEE Internet of Things Journal, 2024.
Xiaochen Zhu, Xinjian Luo, Yuncheng Wu, Yangfan Jiang, Xiaokui Xiao, and Beng Chin Ooi. Passive inference attacks on split learning via adversarial regularization. ar preprint u114::331011448, 2023.
A Ablation Study on HuSCF-GAN Components
In this section, present the ablation study conducted to evaluate the contributions of different components of HuSCF-GAN toward overall model performance. Specifically, we investigate the impact of: (i) the Clustering Component, (ii) the KLD Component for intra-cluster weighting to address non-IID data, and (iii) using both components together. To evaluate these configurations, we select the Two-Domain Highly Non-IID test case under varying conditions.
As illustrated in Figures 18a and 18b image generation performance is primarily driven by the clustering -hirhhhhhhhhhhhhhhh
component. The removal of the KLD weighting component- which is responsible for handling intra-cluster a marginal effect on performance. However, removing the clustering component results in a significant performance drop. In such a case, the model tends to bias towards the MNIST dataset, leading to a much higher MNIST score compared to FMNIST.
non-IID characteristics-Be
HuSCF-GAN + KLD HuSCF-GAN + Clustering
HuSCF-GAN + Clustering + KLD
9
9
MNIST Score
FMNIST Score
7
6
6
3
3
0
50
100
150
200
250
50
100
150
200
250
Total Number of Epochs
Total Number of Epochs
(a) MNIST Score vs. Training Epochs
(b) FMNIST score vs. Training Epochs
Figure 18: Image Generation Scores
Two-Domains Highly Non-IID Data
Table 23 further supports these findings. The highest evaluation metrics are achieved when both the clustering and KLD weighting components are enabled. Notably, the clustering component has a more substantial impact. Removing causes a significant reduction (over 20%) in FMNIST performance due to the model overfocusing on the easier MNIST dataset. Although the KLD component plays a smaller role, it still contributes positively: removing it causes approximately a 1% drop the evaluation metrics across both datasets. The relatively smaller impact attributed the shared layers among clients in the model architecture, which reduces the negative effects of intra-cluster variance. Nonetheless, the combination of both components yields the optimal performance.
39

---

Published in Transactions on Machine Learning Research (01/2026)
Table 23: Ablation Study Two-Domains Intense Non-IID Data
MINIST Detueet
FMINET Datusst
Accuracy
Precision
Rocall
Scoce
PPB
Accuracy
Precision
Rocal
Sooce
FPB.
Huddy GAX
KLn
94.415
17
91-2525 40-47
0.5475-0.04
50% in
65. C475 40
02007466677
1.335-0.30
HuScE-GAN Chaserrng
33.88lica1
56, 04UT5520-4 44
50 uul 2544
03.018
41.54/520
25-
20.25
2.178-0.20
Claening
96.1075-0.62
B Ablation Study on Genetic Algorithm Hyperparameters
In this section, we present an ablation study to evaluate the impact of different hyperparameters of the genetic algorithm, namely Population Size (PS), Crossover Rate (CR), and Mutation Rate (MR). The ablation is performed by varying each hyperparameter individually while keeping the others fixed at their baseline values.
Since the genelic algorithm is used to select the cutpoints of the model, it siguificantly affects the system latency. Therefore, we use latency as the primary metric for this study. While changes in the genetic algorithm parameters have minimal impact on other performance metrics, their effect on latency is pronounced and readily observable.
Table 24: Ablation Study on Genetic Algorithm Hyperparameters
GA Hyper-
PS 1000
Ps 1000
PS 1000
PS 1000
Ps 1000
PS- 1000
PS- 1000
PS
PS 300
P$ 2000
CR=0. 0.7
CR= 0.3
CR = 0.5 =R=
CR= = 0.9
CR=01 0.7
CR= 0.7
CR=01 0.7
CR= 0.7
CR= 0.7 0.00 7.9
CR= 0.7
parameters
MR= 0.01
MR = 0.01
0.01 7.8
MR = 0.001
MR = 0.05
MR =
=
MR= 0.01
Latency (s)
7.8
8.21
7.8
7.8
8.3
9.7
8.22
8.13
Table 24 shows that our chosen hyperparameters achieve the lowest latency. However, other parameter selections yield comparable latency, suggesting that multiple configurations could be used without compro- mising performance. The results indicate that reducing the population size (e.g., to 500 or below) leads to noticeable degradation in the objective function (latency). This is because smaller population reduces solution diversity, thereby restricting the exploration capability of the algorithm. Conversely, increasing the population size excessively (e.g., beyond 2000) yields minimal latency improvement while substantially increasing computational cost. Similarly, low crossover rates (< 0.3) hinder performance by limiting genelic diversity, whereas excessively high rates (z 0.9) offer negligible gains while adding computational overhead. Regarding mutation, higher rates (z 0.1) degrade performance due excessive randomness, while very low rales (< 0.001) increase the risk of premature convergence local optima.
Overall, these observations validate our initial hypothesis that appropriate balance between exploration and efficiency is crucial-one that is effectively achieved through our selected hyperparameter configurations.
C Further Comparison Between HuSCF-GAN and PFL-GAN
This section presents an extended comparison between HuSCF-GAN and PFL-GAN, based on the evaluation scenarios introduced in the original PFL-GAN paper [Wijesinghe et al. 2023). Specifically, two test cases are considorod: the label skewness and the Byzantine scenarios. Both consist of 20 clients, cach having 300 samples per label, except for randomll chosen labels that only have 15 samples each. The key difference is that the label skewness scenario uses clients from a single domain (MNIST), while the Byzantine scenario includes 10 MNIST clients and 10 FMNIST clients. In both scenarios, PFL-GAN achieves scores similar to those shown in its original paper.
In the first scenario, shown in Figure 19 HuSCF-GAN achieves slightly higher image ion scores com- pared to PFL-GAN. Additionally, HuSCF-GAN yields approximately 1.5% improvement across classification metrics, as reported in Table 25
In the second scenario, summarized in Table 26 HuSCF-GAN outperforms PFI-GAN classification metrics the MNIST dataset, with an improvement of approximately 1%. On the FMNIST dataset, HuSCF-GAN performs comparably, with slight decrease in scores. Figure 20 shows that HuSCF-GAN GAN also achieves marginally better image generation quality in this setting.
40

---

Published in Transactions on Machine Learning Research (01/2026)
HuSCF- PFL-GAN
MNIST Score
5
2
100
150
250
Total Number of Epochs
Figure 19: MNIST Score vs. Training Epochs Comparison between HuSCF-GAN and PFL-GAN
label skewness scenario (Wijesinghe et al. 2023
Table 25: Further Comparison between PFL-GAN & HuSCF-GAN
Label Skewness Scenario
MNIST Datasct
Accuracy ?
Precision 1
Recall
F1 Score
FPR.
PFL-GAN
97. 97.18% +0046
97.21% +-0.466
97 17.18%
97.17% +0.46
0.31% 1-1.11
98.11%++0.44
98.13%++0.44
08.08%=0.44
98.10%
0.21%
Table 26: Further Comparison between PFL-GAN & HuSCE-GAN
Byzantine Scenario
MNIST Dutuee
FMNIST Duimet
Accuracy
Precision
Accuracy $3.999550.37
Preciston 53.5055-60000
Score
BUSCP-GAN
97.767-20033
07 07-779220033
07 07.78%920.88
07. 07.75%640.3
33.4475-0000
41

---

Published in Transactions on Machine Learning Research (01/2026)
HuSCF-GAN - PFI.-GAN
10
10
9
9
MNIST Score
FMNIST Score
3
50
150
200
250
50
100
150
200
250
Epochs
Epochs
(a) MNIST Score Training Epochs
(b) FMNIST Score Training Epochs
Figure 20: Comparison of HuSCF-GAN and PFL-GAN Byzantine Scenario
Wijessnghhe al.
2023
D Further Elaboration on the Reduction Strategy
D.1 Overview
To address the scalability limitations of the dieettbbssd Genetic Algorithm (GA), we introduce profile-base reduction strategy. In this approach, instead of optimizing over all individual clicnts, the scarch space is reduced to a set of unique device profiles, where each profile groups clients that share identical computational and communication characteristics (see Figure 6 The GA then operates over these profiles rather than individual clients, effectively transforming the optimization process from client-level profile-level
D.2 Reduction Principle and Scalability
In the client-based configuration, the GA treats every client as an independent entity in the search space. While this ensures maximum fidelity to the real system, the resulting search space grows exponentially with the number clients, leading to high computational complexity and slow convergence.
The profile-based strategy, in contrast, achieves a structural reduction rather than quantitative one. By aggregating clients with identical characteristics into common profiles, the GA optimizes that scales with the number of profiles rather than the number of clients. Since the number of profiles typically remains much smaller than the total number of devices, even in large-scale deployments, this strategy substant ially reduces computational cost while preserving the representativent of client behaviors.
search space
D.3 Impact Algorithmic Complexity
As the number of clients increases, the computational complexity of the profile-based strategy remains largely constant, because it scales with the number of profiles rather than the total number of clients. In this setting, the GA operates on a compact search space defined by profile-level configurations, resulting in a much lower time and space complexity compared to the client-based GA.
Although this work assumes that all clients within profile have identical computational and communication capabilities, this assumption serves as proof of concept. In realistic large-scale systems, clients can still be effectively clustered into representative profiles based similarity, keeping the number of profiles limited and ensuring the scalability of the approach.
42

---

Published in Transactions on Machine Learning Research (01/2026)
D.4 Impact on Solution Quality
As the number of clients scales, the profile-based reduction strategy consistently maintains- and in some cases improves- quality of the obtained solutions while drastically reducing computational complexity. Because the GA operates over a smaller yet more structured search space, it converges faster and more stably without degrading performance.
Experimental results with 100 devices illustrate this effect clearly shown in Table 27 the profile-based GA achieved the lowest latency within the smallest number of generations, outperforming the client-based GA both in convergence speed and final latency. This improvement arises from the reduced and more structured search space, which allows the GA to explore more efficiently and avoid being trapped in local optima an issuc common in large, complex search spaces.
Table 27: Comparison between profile- proile-based based and client-based GA performance using 100 devices.
Strategy
Achieved Latency (s)
Generations to Convergence
Profile-based
7.8
12
Client-basod
8.26
488
D.5 Effect of System Synchronicity
Assumption: The system is assumed to operate in a synchronous setting, where the server waits for all clients participating in given layer- effectivel for the slowest client before proceeding. Under this assumption, the profile-based based strategy maintains reachability to all solutions achievable by the fiientbbased GA. Any configuration change that could improve overall latency either (i) provides no net benefit when applied individual clients within profile, (ii) can be equivalently represented at the profile level, since all clients within profile share identical computational and communication characteristics.
If the system were instead asynchronous, where the server does not wait for slower clients, some configurations accessible to the client-based GA might not be representable at the profile level. However, even under such a setting, the profile-base based strategy is expected to achieve reasonable (even not the best)) lateney while preserving significantly lower computational cost.
D.6 Effect of Profiling Assumptions
The performance of the profile-based strategy depends on the assumption regarding client similarity within each profile. In this work, we assume that clients in the same profile are identical in their computational and communication characteristics. Under this assumption, there is no information loss, and the profile-based GA can explore the same solution space the client-based GA while maintaining quality and reachability.
In more realistic scenarios, this assumption can be relaxed by clustering clients with similar (rather than identical) characteristios into shared profiles. This introduces a minor approximation error, as each profile represents an averaged abstraction of its clients. Nevertheless, the resulting model remains highly effec- live, delivering near-optimal solutions with a fraction of the computational effort required by client-level optimization, making it a scalable and practical approach for large deployments.
D.7 Summary
In summary, the profile-basee based reduction strategy offers highly scalable and efficient alternative to client-level GA optimization. By operating over reprosentative device profiles rathor than individual clients, it significantly reduces computational complexity while preserving solution quality and convergence properties.
43


Reviews:
[{"review_id": "hdOYWHuepj", "reviewer": "Reviewer_EDsn", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper studies an important problem of federated learning with possible insufficient computational costs. The authors propose a decentralized GAN training algorithm.", "claims_and_evidence_yn": "Yes", "claims_explanation": "1. The paper is well-written and easy to follow.\n2. The method is sound and the figure is clear.\n3. Experiments show the effectiveness of the proposed method.", "audience_yn": "Yes", "audience_explanation": "Federated learning is a popular research area in machine learning.", "requested_changes": "1. It would be better to include more experiments with more different datasets, such as time series and audio.\n2. It would be better to provide a case study to intuitively show the effectiveness of the proposals.\n3. It is suggested to provide computational complexity analysis, i.e., space and time complexities.", "broader_impact_concerns": "NA", "additional_comments": "NA", "extra_scores": {}, "extra_text": {}}, {"review_id": "b1CVj9Ic0F", "reviewer": "Reviewer_4ec9", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper addresses a complex set of challenges in training generative AI models, specifically GANs, in distributed environments. The authors identify that real-world distributed learning is often constrained by data heterogeneity (non-IID), device heterogeneity (varying compute and communication capabilities), multi-domain data sources, and strict data-sharing and privacy constraints.\n\nTo tackle these challenges, the paper proposes a novel distributed generative AI framework named HuSCF-GAN. This framework integrates several techniques in a cohesive manner:\n\n1. To handle device heterogeneity, the model is dynamically split between the client and a server. The system employs a genetic algorithm to determine the optimal \"cut points\" for each client to minimize overall training latency. The U-shaped architecture ensures that raw data and labels remain on the client, enhancing privacy\n\n2. To adapt to multi-domain data, the server clusters clients based on the activation similarity from an intermediate layer of the discriminator, grouping clients with similar data distributions.\n\n3. To address data heterogeneity, the federated aggregation within each cluster is weighted not only by dataset size but also by a Kullback-Leibler Divergence (KLD) score calculated from activations. This approach avoids the need to share label distributions, further preserving privacy.\n\n**Weaknesses**\n\n1. The paper acknowledges that the search space for the genetic algorithm grows exponentially with the number of clients and uses a client down-sampling approach to simplify the optimization. While validated on a small scale, the effectiveness and sub-optimality gap of this approximation in very large-scale systems (e.g., thousands of clients) warrants further discussion.\n\n2. Although the approach offloads computation from clients, it still relies on a central server for model splitting, clustering, and federated aggregation. This positions it as a federated, not a fully decentralized, topology, a nuance that could be discussed more explicitly.", "claims_and_evidence_yn": "Yes", "claims_explanation": "1. The experiments, conducted across six scenarios of increasing complexity, systematically demonstrate that the proposed method outperforms or significantly outperforms multiple baselines on image generation scores and classification metrics. The performance advantage is particularly evident in complex multi-domain, non-IID settings.\n\n2. The latency comparison clearly shows that the method achieves an order-of-magnitude latency reduction compared to approaches that train the full model on the client, such as FedGAN and PFL-GAN, which is critical for resource-constrained edge devices.\n\n3. The design of the U-shaped split learning architecture and the activation-based KLD calculation mechanistically ensure that raw data and labels do not leave the client, providing clear evidence for the privacy-preserving aspects of the framework.", "audience_yn": "Yes", "audience_explanation": "Yes, the target audience for this paper is quite broad, as it sits at the intersection of several popular and active research areas, including generative AI, federated learning, edge computing, and privacy-preserving machine learning.", "requested_changes": "1. I would recommend the authors add a brief discussion on the potential challenges of implementing such a complex system (combining a genetic algorithm, clustering, and federated learning), such as hyperparameter sensitivity and the overhead of coordinating the different components.\n\n2. It would be beneficial to elaborate on the approximation strategy used for the genetic algorithm. For instance, how does the down-sampling ratio affect the quality of the final solution? Can any guarantees be made about the proximity to an optimal solution in large-scale client scenarios?\n\n3. The experiments are based on MNIST and its variants, which is appropriate for a proof-of-concept. Acknowledging this as a limitation in the conclusion and speculating on the potential performance and challenges on more complex, real-world datasets (e.g., medical images, autonomous driving scenes) would be a valuable addition.", "broader_impact_concerns": "N.A.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "vIaCTqr4eT", "reviewer": "Reviewer_tuMr", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper introduces **HuSCF-GAN (Heterogeneous U-Shaped Split Clustered Federated GANs)**, a distributed generative AI framework designed for heterogeneous, multi-domain environments under strict data sharing constraints. The work tackles four central challenges in decentralized GAN training:  \n\n1. Data heterogeneity (non-IID distributions)  \n2. Device heterogeneity (compute + network variation)  \n3. Multi-domain datasets  \n4. Strict data sharing constraints (no raw/synthetic data, no labels shared)  \n\n**Key contributions:**  \n- **Novel methodology:** Combines a genetic algorithm for cut-point optimization, heterogeneous U-shaped split learning for privacy-preserving training, and clustered KLD-weighted federated learning for adapting to domain differences.  \n- **Latency model + optimization:** Explicit mathematical model of client/server compute and communication costs, optimized with a genetic algorithm to minimize per-iteration latency.  \n- **Privacy-preserving aggregation:** Proposes activation-based KLD scoring (vs. prior label-based methods) to avoid label sharing while achieving equivalent performance.  \n- **Extensive evaluation:** Across six scenarios (single-domain IID/non-IID, multi-domain IID/non-IID, highly non-IID, and four-domain scalability), HuSCF-GAN consistently outperforms baselines (MD-GAN, FedGAN, Federated Split GANs, HFL-GAN, PFL-GAN):  \n  - $1.1 \\times$–$2.2 \\times$ higher image generation scores  \n  - $10\\%$–$50\\%$ higher classification metrics in challenging multi-domain non-IID settings  \n  - $5 \\times$–$58 \\times$ lower training latency, especially on resource-constrained devices  \n\n**Strengths:**  \n- Addresses all four critical challenges jointly (a first among distributed GAN works).  \n- Strong technical rigor: clear latency model, formalized optimization, and privacy-preserving weighting scheme.  \n- Extensive and fair evaluation across multiple datasets, baselines, and scenarios.  \n- Practical relevance to federated learning in IoT/edge-device ecosystems.  \n\n**Weaknesses:**  \n- Experiments are limited to relatively small image datasets (MNIST-family). The scalability to modern high-dimensional data (e.g., CIFAR, ImageNet, medical images) remains untested.  \n- The approach depends on a central server for middle-layer hosting, which may limit its applicability in fully decentralized settings.  \n- Privacy is preserved at the label/data level, but advanced adversarial leakage attacks (e.g., gradient inversion) are not discussed.", "claims_and_evidence_yn": "Yes", "claims_explanation": "The experiments systematically test the algorithm in conditions ranging from favorable (IID single-domain) to extremely challenging (multi-domain, highly non-IID). In simple scenarios, HuSCF-GAN performs on par with baselines, confirming correctness. In complex scenarios, it clearly outperforms thereby validating its design choices (heterogeneous splitting, clustering, KLD-weighted FL).  \n\nThe latency analysis is especially convincing. Unlike many works that ignore communication/computation tradeoffs, this paper explicitly models them and validates with empirical device simulations. The privacy claims are also substantiated via comparison with label-based approaches.", "audience_yn": "Yes", "audience_explanation": "The paper addresses a timely and important problem at the intersection of **federated learning, distributed training, and generative AI**. TMLR’s readership, which includes researchers in machine learning systems, privacy-preserving ML, and generative modeling, would find this work relevant because:  \n\n- It introduces a **novel integration** of split learning, federated learning, and clustering in generative model training.  \n- It offers a practical framework for **edge/IoT deployment**, a key application domain of interest.  \n- It provides methodological advances (latency-optimized cut-point selection, activation-based privacy-preserving KLD) that could inspire further research.  \n\nThe findings advance both the **theoretical understanding** of distributed GANs and their **practical feasibility** under real-world constraints.", "requested_changes": "**Suggested (would strengthen but not mandatory):**  \n1. **Evaluation on larger-scale datasets:** Demonstrating performance beyond MNIST-family datasets (e.g., CIFAR-10/100 or medical imaging datasets) would strengthen claims of generalizability.  \n2. **Privacy discussion:** While the method avoids raw data and label sharing, it should explicitly address risks of **gradient inversion attacks** or adversarial leakage from activations/gradients, and outline mitigation strategies.  \n3. **Comparison with diffusion or transformer-based generative models:** Even a brief discussion of applicability would broaden the paper’s scope.  \n4. **Real-world latency validation:** A small-scale physical deployment (even with 10–20 devices) would better ground the latency claims beyond simulations.  \n5. **Ablation on GA hyperparameters:** Sensitivity analysis for population size, mutation/crossover rates, and $\\beta$ (in weighting scheme) would provide more robustness evidence.", "broader_impact_concerns": "- The work has **positive societal potential**: enabling privacy-preserving generative AI on distributed, resource-limited devices, including healthcare and sensitive data domains.  \n- **Concerns:**  \n  - While data/label privacy is preserved, information leakage via intermediate activations or gradients could still be exploited by adversaries.  \n  - No explicit safeguards (e.g., differential privacy, homomorphic encryption) are integrated in the current implementation.  \n- **Recommendation**: The paper should expand its Broader Impact section to explicitly discuss these risks and possible mitigations.", "additional_comments": "- The paper is well-written and structured, though dense in equations. Adding more **intuitive diagrams** (e.g., GA optimization process, communication flow) would improve accessibility.  \n- The results section is strong; however, including **confidence intervals or statistical significance testing** would further substantiate performance claims.  \n- Future work suggestions are thoughtful; in particular, exploring applicability to **diffusion models and LLMs** is an exciting direction that would extend the contribution substantially.", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)