GraphFedMIG: Imbalance Mitigation in Federated Graphs

• GraphFedMIG is a federated graph learning framework that mitigates class imbalance via generative data augmentation and mutual information-guided synthesis.
• It employs a hierarchical GAN architecture with client clustering and class-specific prototypes to enhance minority-class representation.
• Experimental results demonstrate significant improvements in minority accuracy and recall over baselines across diverse real-world graph datasets.

GraphFedMIG is a federated graph learning framework for class-imbalanced node classification that treats imbalance mitigation as a federated generative data augmentation problem. In the formulation reported by "GraphFedMIG: Tackling Class Imbalance in Federated Graph Learning via Mutual Information-Guided Generation" (Li et al., 14 Aug 2025), multiple clients collaboratively train graph neural networks without sharing raw graph data, while a hierarchical generative adversarial design, class-specific prototypes, and a mutual information-guided mechanism are used to improve minority-class representation under non-IID client distributions. The framework is motivated by the observation that, in federated graph learning, class imbalance is especially destructive because minority-class nodes are often embedded in biased neighborhoods, which degrades message-passing features and biases the global model toward majority classes (Li et al., 14 Aug 2025).

1. Problem formulation in federated graph learning

GraphFedMIG is defined in the setting of federated graph learning with $M$ clients. Each client $i$ holds a private local graph $G_i = (V_i, E_i)$, a node feature matrix $X_i \in \mathbb{R}^{|V_i|\times d}$, and labels $Y_i$. Let $p_i(y)$ denote the local label distribution over $H$ classes. The non-IID condition means that $p_i(y)$ differs substantially across clients, and this may include severe class imbalance in which minority classes contain few nodes on some clients (Li et al., 14 Aug 2025).

The baseline federated objective is the weighted average of local losses,

$$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$

with parameter aggregation

$\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$

In the reported analysis, this objective becomes biased toward majority classes under imbalance, and minority-class performance deteriorates. In graph data, the problem is compounded by neighborhood bias: minority-class nodes are often surrounded by majority-class neighbors, making message-passing embeddings less discriminative (Li et al., 14 Aug 2025).

The GNN backbone is described through the standard message-passing recursion

$i$0

with prediction

$i$1

and local supervised loss given by cross-entropy. Within this setting, GraphFedMIG reframes imbalance handling not as class re-weighting or focal loss, but as a federated feature-generation problem centered on minority coverage (Li et al., 14 Aug 2025).

2. Hierarchical GAN architecture and client clustering

The core architectural choice is a hierarchical GAN in which each client $i$2 owns a local generator $i$3, while clients are partitioned into $i$4 clusters $i$5 and each cluster shares a discriminator $i$6. This many-generators-to-one-discriminator design is described as providing tailored supervision that respects client heterogeneity while controlling computational and communication overhead (Li et al., 14 Aug 2025).

The generators synthesize graph embeddings rather than edges or subgraphs. For a node on client $i$7, $i$8 takes node attributes processed by a GNN backbone with a terminal linear layer and outputs a synthetic feature vector $i$9. These synthetic embeddings are then used adversarially through cluster discriminators, contrastively through mutual-information alignment to local real feature prototypes, and indirectly to augment minority-class representation (Li et al., 14 Aug 2025).

Generation is class-aware through prototypes rather than explicit cGAN label concatenation. Discriminators include an $G_i = (V_i, E_i)$0-way softmax over classes, and MI loss couples synthetic features with class-specific real prototypes. This suggests that conditionality is implemented through representation alignment rather than explicit label-conditioned latent-variable injection (Li et al., 14 Aug 2025).

Client grouping is performed once as a preprocessing step through agglomerative hierarchical clustering. For each client $G_i = (V_i, E_i)$1 and class $G_i = (V_i, E_i)$2, the mean synthetic feature is computed as

$G_i = (V_i, E_i)$3

Clusters are iteratively merged according to cosine similarity until the maximum inter-cluster similarity falls below a threshold $G_i = (V_i, E_i)$4. If

$G_i = (V_i, E_i)$5

then the implementation uses

$G_i = (V_i, E_i)$6

The clustering threshold controls cluster granularity, and the reported experiments note a trade-off in which higher $G_i = (V_i, E_i)$7 improves minority metrics but may reduce overall accuracy and recall (Li et al., 14 Aug 2025).

3. Prototype-based supervision and mutual information-guided generation

GraphFedMIG uses privacy-preserving class prototypes as the main shared statistics. For client $G_i = (V_i, E_i)$8 and class $G_i = (V_i, E_i)$9, the local real-feature prototype is

$X_i \in \mathbb{R}^{|V_i|\times d}$0

where $X_i \in \mathbb{R}^{|V_i|\times d}$1 is the set of real samples of class $X_i \in \mathbb{R}^{|V_i|\times d}$2 on client $X_i \in \mathbb{R}^{|V_i|\times d}$3. For cluster $X_i \in \mathbb{R}^{|V_i|\times d}$4 and class $X_i \in \mathbb{R}^{|V_i|\times d}$5, the aggregated cluster prototype is

$X_i \in \mathbb{R}^{|V_i|\times d}$6

The cluster prototype set is $X_i \in \mathbb{R}^{|V_i|\times d}$7 (Li et al., 14 Aug 2025).

The cluster discriminator $X_i \in \mathbb{R}^{|V_i|\times d}$8 is an $X_i \in \mathbb{R}^{|V_i|\times d}$9-way classifier whose loss compares outputs on synthetic cluster features and outputs on real prototypes:

$Y_i$0

where $Y_i$1. The use of discriminator outputs on prototypes as soft targets is explicitly characterized as adaptive and privacy-preserving, since only prototypes rather than raw data are shared (Li et al., 14 Aug 2025).

At the generator level, three losses are combined. The first is a classification loss on real data,

$Y_i$2

The second is an adversarial-diversity term derived from a MAD-GAN-style objective and expressed through KL and Jensen–Shannon structure:

$Y_i$3

where

$Y_i$4

The paper states that this is equivalent to a constant-shifted Jensen–Shannon divergence between the true distribution and the aggregate of peer generators, thereby encouraging both realism and mode coverage (Li et al., 14 Aug 2025).

The third term is a mutual information fidelity loss. Using a projection head $Y_i$5 and the InfoNCE lower bound, GraphFedMIG maximizes mutual information between local real prototypes and synthetic features of the same class:

$Y_i$6

Positive pairs are $Y_i$7 and negatives are $Y_i$8 for $Y_i$9. The final generator objective is

$p_i(y)$0

This arrangement is intended to balance class-aware realism, diversity, and fidelity to client-specific minority representations (Li et al., 14 Aug 2025).

4. MIGMA: informational weighting and personalized parameter correction

The distinctive component of GraphFedMIG is the mutual information-guided mechanism, abbreviated in the paper as MIGMA. It formalizes client contribution through a virtual cluster generator,

$p_i(y)$1

where $p_i(y)$2 is a nonlinearity, $p_i(y)$3 is client $p_i(y)$4’s contribution weight, and $p_i(y)$5 is a permutation matrix used to ensure permutation invariance (Li et al., 14 Aug 2025).

The weighting signal is defined by a Jensen–Shannon-divergence-based score between the client posterior and the cluster posterior:

$p_i(y)$6

with

$p_i(y)$7

The score is estimated with a robust nearest-neighbor method rather than binning. A larger $p_i(y)$8 indicates that a client contributes statistically unique class information, often associated with minority classes (Li et al., 14 Aug 2025).

The optimization objective for the weights is written as

$p_i(y)$9

In practice, $H$0 is taken proportional to $H$1 and normalized within the cluster. Instead of averaging client generators, GraphFedMIG applies personalized rescaling,

$H$2

A reported update step is

$H$3

This mechanism is explicitly presented as counteracting aggregation bias and prioritizing rare, high-value information (Li et al., 14 Aug 2025).

The paper further reports server-side aggregation of discriminators across clusters,

$H$4

followed by redistribution to initialize cluster discriminators in the next round. This yields a mixed local-global regime: generators remain local and are not averaged via FedAvg, whereas adversarial knowledge in the discriminators is periodically shared across the clustered federation (Li et al., 14 Aug 2025).

5. Training pipeline, implementation, and systems characteristics

The reported training pipeline comprises the following stages: one-time pre-training of local GNNs and agglomerative clustering; local prototype computation on each client; server-side cluster prototype aggregation; local generator training with the composite loss; cluster discriminator training on synthetic feature summaries or mini-batch features; MI estimation and weight normalization within each cluster; parameter correction using $H$5; server aggregation of discriminators; and continuation for $H$6 rounds (Li et al., 14 Aug 2025).

The communication pattern is described as server $H$7 cluster discriminators $H$8 clients. Clients share prototypes and synthetic feature statistics rather than raw data. The shared GNN backbone parameters follow local training, and no FedAvg is applied to generators. This suggests that GraphFedMIG is not merely a clustered variant of federated averaging, but a personalized clustered training scheme whose central shared objects are discriminators and prototype-level summaries (Li et al., 14 Aug 2025).

In the reported implementation, the generator backbone is a two-layer GraphSAGE with hidden dimension $H$9 and a terminal linear adapter; the discriminator is a three-layer MLP with softmax over $p_i(y)$0 classes; and the projection head for InfoNCE is a small MLP. Optimization uses Adam with learning rate $p_i(y)$1, for $p_i(y)$2 communication rounds, with results averaged over $p_i(y)$3 seeds on a single NVIDIA RTX 3060 (Li et al., 14 Aug 2025).

The paper gives specific communication payloads per round: FedAvg $p_i(y)$4 MB, FL+HC $p_i(y)$5 MB, FedSpray $p_i(y)$6 MB, and GraphFedMIG $p_i(y)$7 MB. The overhead is characterized as comparable and of the same order of magnitude, with the additional cost attributed to generator parameters, discriminator parameters, and low-dimensional prototypes (Li et al., 14 Aug 2025).

On privacy, GraphFedMIG does not share raw data and can incorporate $p_i(y)$8-differential privacy through the Gaussian mechanism:

$p_i(y)$9

The reported finding that moderate noise with $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$0 yields peak performance on Facebook is interpreted in the paper as a regularization effect for generators (Li et al., 14 Aug 2025).

6. Experimental evidence, limitations, and naming ambiguity

The evaluation uses four real-world node-classification datasets with class imbalance: Elliptic with $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$1 nodes, $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$2 edges, $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$3 features, $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$4 classes, $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$5 clients, and minority proportion $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$6; Twitch with $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$7 nodes, $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$8 edges, $$\min_{\theta}\;\sum_{m=1}^{M}\frac{N_m}{N}\,\mathcal{L}_m(\theta;\mathcal{D}_m),\quad N=\sum_{m=1}^{M}N_m,$$9 features, $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$0 classes, $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$1 clients, and minority proportion $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$2; Facebook (Page-Page) with $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$3 nodes, $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$4 edges, $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$5 features, $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$6 classes, $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$7 clients, and minority proportion $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$8; and Actor with $\theta \leftarrow \sum_m \frac{N_m}{N}\theta_m.$9 nodes, $i$00 edges, $i$01 features, $i$02 classes, $i$03 clients, and minority proportion $i$04. The metrics are overall accuracy, minority accuracy, overall recall, and minority recall. Baselines are Local-only, FedAvg, FL+HC, and FedSpray (Li et al., 14 Aug 2025).

Selected reported results show that on Elliptic, GraphFedMIG attains overall accuracy $i$05, minority accuracy $i$06, overall recall $i$07, and minority recall $i$08, improving over FL+HC by $i$09, $i$10, $i$11, and $i$12, respectively. On Facebook, the method reaches overall accuracy $i$13, minority accuracy $i$14, overall recall $i$15, and minority recall $i$16, with the strongest gains over baselines appearing in minority-oriented metrics. On Actor, the reported values are overall accuracy $i$17, minority accuracy $i$18, overall recall $i$19, and minority recall $i$20. Twitch is the main exception in overall accuracy, where FedSpray reaches $i$21 and GraphFedMIG reports $i$22, though GraphFedMIG still achieves the best overall recall $i$23 and minority recall $i$24 (Li et al., 14 Aug 2025).

Ablation on Facebook compares HC, HC+GAN, HC+GAN+MI loss, and the full model with MIGMA. The reported sequence for overall accuracy is $i$25; for minority accuracy, $i$26; for overall recall, $i$27; and for minority recall, $i$28. The convergence analysis in the experiments states that GraphFedMIG stabilizes around $i$29 rounds on Elliptic, whereas the HC+GAN variant requires about $i$30 rounds (Li et al., 14 Aug 2025).

The paper identifies several limitations. Extreme imbalance or highly skewed topology may still challenge generator stability, and GAN training can remain unstable. The method generates node feature embeddings rather than full subgraphs, so explicit neighborhood-conditioned generation is left as future work. The privacy-utility trade-off under differential privacy requires tuning of $i$31 and $i$32, and the paper points to alternative MI estimators such as MINE, adaptive clustering, and privacy-preserving discriminators as future directions (Li et al., 14 Aug 2025).

A recurring source of confusion is naming. In the 2025 literature, GraphFedMIG denotes the mutual information-guided generative framework described above (Li et al., 14 Aug 2025). A separate 2024 paper, "FedGIG: Graph Inversion from Gradient in Federated Learning" (Xiao et al., 2024), notes that “GraphFedMIG” may appear as a descriptive alias for a graph gradient-inversion attack and states that, if encountered as “Graph Federated Model Inversion from Gradients,” it matches FedGIG in scope and design. That usage refers to a different problem—privacy attack via graph inversion from gradients—rather than to class-imbalance mitigation in federated graph learning (Xiao et al., 2024).