PaperlayerView exact revision on arXiv

Source-linked AI summary

Global Federated Learning Strategies for Building Efficient Personalized Models

Seongyoon Kim

arXiv:2608.15107v1cs.LG

TL;DR

Heterogeneity across users makes it difficult for federated learning to maintain both global and personalized performance. The paper develops feature-normalization and feature-distillation strategies for preserving global knowledge during personalization, finding that greater heterogeneity produces larger feature-norm disparities and that feature normalization performs strongly in federated learning.

  • Problem

    User heterogeneity in data quantity and label distribution remains a central challenge for federated learning.

  • Method

    The paper introduces feature normalization and feature distillation to align local representations while preserving global-model knowledge.

  • Results

    Greater data heterogeneity produces larger feature-norm disparities, while feature normalization shows superior federated-learning performance.

  • Takeaways & Limitations

    Feature representations, rather than classifier weights alone, are a key target for improving federated-learning performance under heterogeneity.

  • Takeaways & Limitations

    Strengthening local alignment can cause models to forget information from unobserved classes, degrading global-model performance.

Abstract

from arXiv · show

Federated learning (FL) is a practical framework that can train models on distributed user data while guaranteeing data privacy; however, due to heterogeneity in which each user has a different data distribution, problems frequently arise where both global and personalization performance deteriorate simultaneously. This dissertation presents methodologies for building efficient personalized models by identifying which strategies are effective in the global training stage and by showing how to preserve global knowledge while securing user-specific performance during local adaptation. First, we show that as data heterogeneity increases, the collapse of feature vectors is a more fundamental bottleneck than classifier weights, and propose a method that directly mitigates the discrepancy in representation magnitude between local and global models. Second, we analyze that a training approach that strengthens local alignment can induce forgetting of global knowledge (e.g., categories not observed locally), and propose a method that achieves both local alignment and global knowledge preservation by combining feature distillation based on the global model's feature vectors. Third, in federated personalized reward model learning with preference heterogeneity, we empirically verify the conventional belief that "increasing the number of global models yields better initialization," and we show that when sufficient local fine-tuning is allowed, a single global initialization can instead provide stronger personalization performance. This study redefines the role of global initialization under data and preference heterogeneity and provides practical training strategies that simultaneously satisfy global knowledge preservation and personalization.

Chapter 2. FedFN: Feature Normalization for Alleviating Data Hetero- … FedFN: Feature Normalization for Alleviating Data Heterogeneity Problem in Federated Learning

Chapter 2 identifies feature-norm discrepancy, rather than classifier-weight distortion, as a central failure mode under heterogeneous federated learning and introduces FedFN to normalize features during training. Experiments report improved robustness and accuracy across heterogeneous, pretrained, and personalized settings.

  • 1.1 Outline: Across the dissertation, effective global strategies stabilize feature learning, preserve transferable knowledge during personalization, and provide initialization that clients can adapt to heterogeneous data and preferences.The overview contrasts FedFN, FedDr+, and single-global-model initialization as strategies for heterogeneous federated learning.
  • 2.1 Introduction: As data heterogeneity increases, FedAVG feature representations deteriorate more than classifier weights, with widening norm gaps across observed, unobserved, local, and global models.The study identifies feature representations as the primary concern rather than classifier weights.
  • 2.5 FedFN: Federated Averaging with Feature Normalization Update: FedFN incorporates feature normalization into federated averaging to eliminate local feature-norm discrepancies and preserve representation quality in highly heterogeneous settings.The method is presented as Federated Averaging with Feature Normalization Update.
  • 2.4.1 4-Factor Analysis of FedAVG: Reducing feature-norm discrepancies between local and global models improves performance, while increasing heterogeneity otherwise worsens inter-class similarity and prototype-weight alignment.FedFN’s analysis links its gains to improved inter-class similarity and reduced norm mismatch.
  • 2.6.1 Compatibility of FN with Existing FL Algorithms: FedFN significantly improves accuracy over FedAVG and consistently outperforms compatible baselines across heterogeneity settings, including cases where Scaffold experiences training failures.The FN update also improves inter-class similarity and discrimination stability.
  • 2.6.2 Comparative Analysis with Pretrained Model: With pretrained models, FedFN consistently outperforms FedBABU and FedAVG, whose performance declines substantially under high data heterogeneity.The reported effectiveness extends to pretrained ResNet18 and foundation models.
  • 2.7.4 Personalized Federated Learning (PFL) Results: For personalized federated learning, two-step methods outperform one-step methods, and FedFN-FT consistently achieves the strongest performance among two-step methods.FedFN-FT is introduced as a fine-tuned PFL algorithm.
  • 2.7.6 Logit Should Be Non-Restricted: Feature-normalization constraints should remain relaxed at the logit level: SphereFed (CE) improves with τ up to 15 but remains less effective than FedFN.At τ = 15, SphereFed (CE) improves over FedBABU and SphereFed (MSE).

FedDr+: Stabilizing Dot-regression with Global Feature Distillation for Federated Learning

FedDr+ combines dot-regression with global feature distillation to improve local alignment while preserving knowledge of unobserved classes. FedDr+ FT extends this approach to personalized federated learning through client-specific fine-tuning.

  • Motivation: Dot-regression improves alignment for observed classes but can forget unobserved-class knowledge, reducing aggregated global-model performance.LDR outperforms CE on observed-class alignment, whereas CE performs better on unobserved classes and global accuracy.
  • Method: FedDr+ integrates feature distillation with dot-regression to stabilize feature dynamics and preserve global knowledge during local training.Feature distillation reduces feature distance for both observed and unobserved classes, improving feature-classifier alignment and global accuracy compared with LDR.
  • Personalized federated learning: FedDr+ FT fine-tunes the FedDr+ global model with the same loss for client-specific data, extending the method to personalized federated learning.This extension is presented as a strategy for improving personalized performance while retaining the FedDr+ global model.
  • Empirical results: FedDr+ achieves the strongest performance among tested dot-regression, feature-distillation, SphereFed, and FedBABU combinations.Feature distillation stabilizes feature dynamics more effectively than the compared regularizers, while MOON, Prox, and logit-based regularizers have distinct limitations.

10 Server Aggregation: θg · 11 GFL output: Θg R = (θg

The section presents server aggregation using θg and specifies the GFL output through indexed global-round and local-training loops. Its implementation iterates over users, local steps, and batches.

  • 11 GFL output: Θg R = (θg: The GFL output is denoted Θg R = (θg.
  • 11 GFL output: Θg R = (θg: The implementation iterates over i = 1, . . . , N.
  • 11 GFL output: Θg R = (θg: The global-round update is written as R+1 ←θg.
  • 11 GFL output: Θg R = (θg: Local training runs for Local Steps e = 1, . . . , E.
  • 11 GFL output: Θg R = (θg: Within local training, batches are indexed by j = 1, . . . , B.

16 PFL outputs: {Θi R+1 = (θi

Dot-regression improves local feature-classifier alignment but can forget unobserved classes and degrade the global model. FedDr+ addresses this limitation through feature distillation, preserving global knowledge while achieving strong global and personalized performance.

  • Dot-regression limitation: Under the NTK regime, dot-regression updates are independent of unobserved class vectors, preventing local feature alignment with those classes.Classifier initialization strongly determines local alignment, leaving global aggregation as the mechanism for generalizing to unseen classes.
  • FedDr+: FedDr+ consistently outperforms CE and dot-regression across training rounds, including the final phase where it surpasses CE in unobserved-class alignment.It also retains stronger erased-class alignment than dot-regression, indicating mitigation of forgetting under changing class distributions.
  • FedDr+: FedDr+ combines dot-regression with feature distillation to improve local alignment while preserving global knowledge across observed, unobserved, and erased classes.The feature-distillation mechanism supports learning observed classes even when class distributions change dynamically.
  • Dot-regression limitation: Dot-regression improves local alignment and accuracy but degrades global performance by forgetting unobserved classes.This limitation motivates FedDr+ as a method for preserving general knowledge during local training.
  • Empirical performance: FedDr+ achieves top performance in global and personalized FL experiments, even when data is distributed unevenly across clients.Across settings, it also consistently outperforms FedAvg and FedBABU, demonstrating robust scalability in large-scale FL.

Are Multiple Global Models Necessary in Federated Personalized Reward Model Learning?

Under preference heterogeneity, a single FL-trained reward model provides a stronger initialization for personalized reward modeling than multiple global models. It remains superior after local fine-tuning and outperforms centralized training across the evaluated settings.

  • Are Multiple Global Models Necessary in Federated Personalized Reward Model Learning?: The study compares Single, Hard, Soft, and Hard-Oracle global-model designs as initializations for personalized reward models under heterogeneous preferences.Clients locally fine-tune from an assigned global model, and evaluations use both real-world and synthetic preference distributions.
  • Are Multiple Global Models Necessary in Federated Personalized Reward Model Learning?: Single consistently achieves higher personalized accuracy than Hard across fine-tuning budgets τ > 0 with K ∈{3, 4, 5} on both datasets.Hard’s modest synthetic initialization advantage is quickly overturned once local adaptation is allowed.
  • Are Multiple Global Models Necessary in Federated Personalized Reward Model Learning?: After about 10 local updates, Single surpasses Hard in all four synthetic preference groups, and the performance gap generally widens as τ increases.At τ = 0, Single is worse than Hard in every group, illustrating that local adaptation determines the eventual advantage.
  • Are Multiple Global Models Necessary in Federated Personalized Reward Model Learning?: Single achieves the highest mean personalized accuracy across all fine-tuning budgets, outperforming Hard, Soft, and Hard-Oracle on both datasets.On the synthetic dataset, Hard-Oracle is strongest at τ = 0, but Single overtakes every multi-global variant after a small amount of local fine-tuning.
  • Are Multiple Global Models Necessary in Federated Personalized Reward Model Learning?: Single consistently outperforms Centralized across fine-tuning budgets τ on both datasets, while Centralized underperforms the random-start baseline Base on the synthetic dataset.The findings indicate that sufficient client-side adaptation before averaging helps produce an effective downstream initialization.

17 Phase 1: Federated training of a single global model

Phase 1 trains a single global model through repeated communication rounds. In each round, clients initialize from the previous global parameters, perform local updates, and participate in FedAvg aggregation at the server.

  • Training proceeds over rounds r = 1, 2, . . . , R.
  • Client m starts from θ(r−1) and runs τ local update steps on Dm.
  • The server performs FedAvg aggregation after client-side updates.

23 Phase 2: Final personalization from the global initialization

Phase 2 defines how global reward-model training produces personalized solutions: the Single design reuses one final global model for local adaptation, while Hard trains and assigns clients among K cluster-specific models before personalization.

  • Single: The Single design reuses the final global model θ(R) solely as an initialization for independent client-side personalization.Each client starts from θ(R) and performs additional local updates on its own preference data.
  • Hard: Hard maintains K cluster-specific global models and sends each client only its assigned model to reduce communication cost.Assignments are updated every T rounds, and clients begin local updates from their assigned cluster model.
  • Hard: Every T rounds, the E-step assigns each client to the model with the lowest validation loss, followed by T rounds of clustered FL in the M-step.Each cluster updates only its own model θk during the subsequent clustered-FL rounds.
  • Hard: Phase 1 independently warms up the K global models for T rounds, while Phase 2 alternates reassignment and clustered training before Phase 3 personalization.This multi-global design jointly trains the global models in Phases 1 and 2, then converts them into personalized PFL solutions in Phase 3.
  • Hard-Balance: Hard-Balance adds a heuristic that moves clients from over-populated to under-populated clusters after reassignment, unlike Hard’s validation-loss-only assignments.Hard is the main method and applies no additional cluster-size control.

28 Phase 1: Warm-up (independent FedAvg for each model)

Phase 1 warms up K models independently with FedAvg over T training rounds, sampling client subsets for each model and round.

  • The warm-up phase iterates over models k = 1, 2, . . . , K.
  • For each model, training proceeds across rounds t = 1, 2, . . . , T.
  • At each round, the method samples a client subset S_t,k and performs the FedAvg update for model k in parallel across selected clients.

34 Phase 2: Dynamic client-driven hard assignment

Phase 2 dynamically reassigns clients using validation loss, optionally balances assignments, and then performs global sampling with cluster-wise training and residual-based aggregation.

  • Client-driven reassignment: Clients are reassigned dynamically according to validation loss.This is identified as the first phase step: client-driven reassignment by validation loss.
  • Client-driven reassignment: Clients are grouped into assignment sets A_k according to their associated model index k(m).The sets are defined as A_k = {m ∈ [M] : k(m) = k} for every k ∈ [K].
  • Optional balancing: Hard-Balance optionally moves a client from the largest assignment set to the smallest when its second-best model matches the smallest set.The optional balancing step is reported as empirically evaluated in Section 4.7.
  • Cluster-wise training: The procedure then uses single global sampling, cluster-wise training, and weighted aggregation with the previous model’s residual.These are listed as subsequent phase steps after reassignment and optional balancing.

49 Phase 3: Final personalization (common to Hard/ Hard-Balance)

In Phase 3, Hard and Hard-Balance use the same personalization procedure: each client selects its best global model by validation loss and fine-tunes it locally on Dm. This produces personalized models directly comparable to the single-global baseline.

  • Shared Phase 3 procedure: Both Hard and Hard-Balance variants are converted to personalized federated learning using the same Phase 3 procedure.The full algorithmic description applies to both modes.
  • Shared Phase 3 procedure: Each client selects its best global model based on validation loss and locally fine-tunes it on Dm.The final assignment uses k=1 before client-side fine-tuning.
  • Shared Phase 3 procedure: The resulting personalized models are directly comparable to the single-global baseline.This comparability follows the common final-personalization procedure.

55 Step 0: Initial soft assignments via validation accuracy · 57 Step 1: Federated multi-global training

The procedure begins with initial soft assignments via validation accuracy and then performs federated multi-global training through repeated local training, expert-wise server aggregation, and periodic assignment updates.

  • 57 Step 1: Federated multi-global training: In Step 1, federated multi-global training iterates over rounds r = 1, 2, . . . , R.
  • 57 Step 1: Federated multi-global training: Each round includes local training at clients.
  • 57 Step 1: Federated multi-global training: The server performs expert-wise aggregation after client-side training.
  • 57 Step 1: Federated multi-global training: The training procedure iterates over experts indexed by k = 1, 2, . . . , K.
  • 55 Step 0: Initial soft assignments via validation accuracy: The procedure includes Step 0, initial soft assignments via validation accuracy.
  • 57 Step 1: Federated multi-global training: Soft assignment weights are updated every T rounds and at the final round r = R.
  • 57 Step 1: Federated multi-global training: The update condition is satisfied when r mod T = 0 or r = R.

68 Step 2: Final personalization phase

The final personalization phase converts the trained multi-global system into client-specific models through fused initialization and local fine-tuning. Despite soft clustering and multiple experts, each client receives only one model per communication round, preserving single-global communication cost.

  • Final personalization phase: Soft-Fusion converts the final multi-global system into personalized models by fusing global models for each client and performing local fine-tuning.The fused initialization is derived from client-specific soft weights over the global models.
  • Final personalization phase: Each communication round sends only one model per client, so Soft-Fusion matches the single-global baseline’s per-round communication cost.This holds despite using soft clustering and multiple experts.
  • Initialization limitation: Under standard LoRA initialization, all global models initially implement the shared base model, making client validation performance nearly identical and soft weights nearly uniform.Random down-projection matrices and zero up-projection matrices make the initial low-rank update BA zero.
  • Initialization limitation: Small, mutually diverse low-rank adapter perturbations are used to make initial global models differ meaningfully and keep soft assignments non-uniform from the beginning.This initialization is introduced to avoid Soft-Fusion collapsing to the single-global baseline.

82 Phase 1: Oracle clustering from local-only models

Phase 1 trains local-only models, computes MCC-based distances across test sets, and applies oracle K-medoids clustering. The resulting fixed clusters initialize cluster-wise global models for subsequent GFL under normalized round budgets.

  • Phase 1: Oracle clustering from local-only models: Local-only models are trained before constructing the client distance matrix.
  • Phase 1: Oracle clustering from local-only models: Distances are computed as D(i,v) ← 1 − S(i,v), where S(i,v) is MCC similarity evaluated across all test sets.
  • Phase 1: Oracle clustering from local-only models: K-medoids is run on the distance matrix to obtain oracle hard clusters {A_k}^K_k=1.
  • Phase 1: Oracle clustering from local-only models: The procedure normalizes the round budget to match each client’s overall training effort in Single GFL, then initializes one global model per cluster.
  • Phase 2: Cluster-wise GFL with fixed oracle clusters: Subsequent cluster-wise GFL uses fixed oracle clusters, with no reassignment during rounds.

96 Phase 3: Final personalization · Chapter 5.

Phase 3 personalizes fixed cluster-global models through one assigned local fine-tuning path, while Chapter 5 concludes that single-global federated initialization achieves the strongest personalization under preference heterogeneity.

  • 96 Phase 3: Final personalization: Each client receives exactly one model from its fixed oracle cluster and locally fine-tunes it into a final personalized solution without validation or model selection.Hard-Oracle matches overall client-side training effort to the Single baseline, providing a reference for multi-global architectures.
  • 4.6.5 LoRA Initialization for Soft-Fusion: Soft-Fusion would collapse to single-global behavior under standard LoRA initialization because all K models begin with the same function and uniform soft weights.With BA = 0, initial validation performance is essentially identical across models, eliminating any additional multi-global effect.
  • 4.6.5 LoRA Initialization for Soft-Fusion: Orthogonal, norm-controlled LoRA perturbations make global models slightly different, producing non-uniform initial soft weights while keeping updates near the base model.The experiments use ε_layer = 0.005 for global scaling and jitter = 0.01.
  • 4.7.1 Within FL: Single vs. Hard-Balance: Single achieves higher personalized accuracy than every Hard-Balance variant for K ∈{3, 4, 5} on both real-world and synthetic datasets.Hard-Balance performs best at K = 4 on the synthetic dataset, matching its four equally sized preference groups.
  • 4.7.1 Within FL: Single vs. Hard-Balance: On the synthetic dataset, K = 4 assigns each preference group to its own cluster, whereas K = 3 merges groups and K = 5 splits a group.Personalization degrades as K deviates from the true number of groups.
  • 4.7.2 Single Remains Best Under Group-Size Imbalance: Under group-size imbalance, Single still achieves the highest mean personalized accuracy across fine-tuning budgets τ, even when K matches the true group count.The imbalanced setting has |G1| = |G4| = 5 and |G2| = |G3| = 15, with assignments that are not group-consistent.
  • Chapter 5.: A single global model trained with federated learning and locally fine-tuned yields the best personalized performance, outperforming multi-global variants and centralized pooled-data training.Clients can adapt the shared initialization using their own preference-derived data, making additional global models unnecessary for strong personalization.
  • Chapter 5.: Chapter 5 identifies stable feature vectors and transferable knowledge as prerequisites for effective personalization under heterogeneous data and preferences.FedFN addresses feature-norm mismatch, while FedDr+ combines dot-regression with global feature distillation to preserve knowledge during local alignment.
Loading 2608.15107v1…