FedRep (Federated Representation) is an algorithm designed to address statistical heterogeneity in federated learning by structurally separating the model into two components: a globally shared representation network (base layers) and a locally personalized prediction head (final layers). The core mechanism alternates between training the local head on a client's private data and updating the global representation using aggregated gradients, allowing the network to learn a universal feature space while each client retains a site-specific classifier optimized for its own label distribution.
Glossary
FedRep

What is FedRep?
FedRep is a personalized federated learning algorithm that partitions a neural network into a shared global feature extractor and personalized local classification heads, enabling clients to learn a common data representation while maintaining unique decision boundaries for their specific data distributions.
This approach directly mitigates the performance degradation caused by non-IID data across clinical institutions. Unlike standard FedAvg, which forces a single global model onto divergent data distributions, FedRep acknowledges that while the fundamental features of a medical image—such as edges and textures—are universal, the diagnostic criteria or label prevalence may vary significantly between hospitals. By decoupling the learning of what to see from how to classify, FedRep achieves superior personalization without compromising the collaborative benefits of the shared representation.
Key Characteristics of FedRep
FedRep partitions a neural network into a shared global representation and a personalized local head, learning a common feature extractor while allowing clients to maintain unique classifiers tailored to their local data distributions.
Representation vs. Classification Split
FedRep decomposes the model into two distinct components: global representation layers (base) and personalized classification heads. The base layers learn a universal feature extractor shared across all clients, while each client maintains its own head for site-specific decision boundaries. This structural separation directly addresses feature distribution skew where different hospitals may diagnose the same condition using slightly different imaging protocols.
Alternating Optimization Procedure
Training proceeds in two alternating phases per communication round:
- Phase 1 (Local Head Update): Clients freeze the global representation and perform multiple local SGD steps to optimize their personalized head for local empirical risk.
- Phase 2 (Representation Update): Clients freeze their local heads and compute gradients with respect to the representation layers, which are then aggregated at the server via FedAvg. This decoupling prevents client drift from pulling the shared feature extractor toward divergent local optima.
Heterogeneity Robustness
FedRep is specifically designed for statistical heterogeneity where client data distributions are non-IID. By confining personalization to the classification head, the algorithm prevents the global representation from being corrupted by conflicting local objectives. Empirical results show FedRep outperforms both FedAvg and Local Fine-Tuning on benchmark federated datasets with high label distribution skew, including CIFAR-100 and FEMNIST under pathological non-IID splits.
Communication Efficiency
FedRep reduces communication overhead compared to full-model personalization approaches. Only the representation layer parameters are transmitted to the server for aggregation; the personalized heads remain local. This is particularly advantageous in cross-silo healthcare settings where bandwidth between hospitals may be constrained, and the classification head constitutes a small fraction of total parameters in deep architectures like ResNet.
Relationship to FedPer
FedRep is a direct algorithmic evolution of FedPer, which also splits base and personalization layers. The key distinction lies in the optimization sequence: FedPer updates both components simultaneously during local training, while FedRep's alternating update scheme provides stronger theoretical convergence guarantees. By isolating head optimization before representation updates, FedRep achieves lower local loss and faster convergence on heterogeneous data partitions.
Convergence Properties
FedRep provides formal convergence guarantees under standard assumptions of smoothness and bounded variance. The alternating minimization framework ensures that the global representation converges to a stationary point of the expected global objective. The number of local head update steps acts as a tunable hyperparameter controlling the personalization-convergence trade-off: more local steps yield better personalization but may slow global representation learning.
Frequently Asked Questions
Clear, technical answers to the most common questions about the FedRep algorithm, its architecture, and its role in personalized federated learning for healthcare.
FedRep (Federated Representation Learning) is a personalized federated learning algorithm that partitions a neural network into a shared global representation (the feature extractor body) and personalized local heads (the classifier). The core mechanism involves a two-step iterative process: first, clients collaboratively learn a common feature representation by averaging the updates of the base layers across the network using standard Federated Averaging. Second, each client independently optimizes its own classification head on local data while keeping the global representation fixed. This structural separation allows the model to learn a universal feature space from all participants while enabling each institution to maintain a unique decision boundary tailored to its specific patient population, effectively addressing statistical heterogeneity without sharing sensitive labels.
FedRep vs. Other Personalization Strategies
Comparing FedRep's representation-classifier split against alternative personalization approaches for handling heterogeneous client data distributions in federated learning.
| Feature | FedRep | FedPer | Per-FedAvg | Ditto |
|---|---|---|---|---|
Personalization mechanism | Local classifier heads + global representation | Local classifier layers only | Meta-learned initialization for local fine-tuning | Proximal regularization term |
Shared components | All base layers (feature extractor) | All base layers | Entire model initialization | Entire model (soft constraint) |
Personalized components | Classifier head only | Final classification layers | Full model after local SGD | Full model with L2 penalty |
Handles feature distribution skew | ||||
Handles label distribution skew | ||||
Handles concept drift across clients | ||||
Communication rounds to convergence | 150-200 | 200-300 | 100-150 | 250-350 |
Local computation overhead | Low (head only) | Low (head only) | High (full model fine-tune) | Medium (full model with proximal) |
Suitable for small local datasets | ||||
Requires public dataset for alignment | ||||
Risk of catastrophic forgetting | Low | Low | Medium | Low |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Related Terms
Explore the architectural components and related algorithms that enable FedRep to learn a shared global representation while maintaining personalized local classification heads.
FedPer
The foundational architecture that FedRep extends. FedPer partitions a neural network into shared base layers and personalized classification heads, synchronizing only the feature extractor across clients. Unlike FedRep, FedPer updates both components simultaneously during local training rather than using an alternating optimization strategy.
Partial Model Personalization
A broader strategy where only a subset of network parameters are personalized while the rest remain globally synchronized. FedRep implements this by design—the representation body stays global, and the prediction head stays local. This reduces communication overhead compared to full-model personalization and mitigates overfitting on small local datasets.
Local Fine-Tuning
The post-aggregation process of further training a global model on a specific client's data. FedRep formalizes this by structurally separating the fine-tuned component (the head) from the frozen global component (the representation). Key distinction: FedRep performs this separation during federated training, not as a post-hoc step.
Domain Adaptation
A methodology for mitigating distribution shift between source and target domains. FedRep's shared representation acts as a domain-agnostic feature extractor, while each client's personalized head adapts to local statistical nuances. This architectural separation naturally handles the covariate shift common in multi-site clinical data.
Federated Transfer Learning (FTL)
Applies knowledge from a source domain to a target domain within a federated network. FedRep complements FTL by providing a reusable global representation that can serve as the source model, with local heads acting as the target-domain adapters—particularly useful when client label spaces differ across institutions.
Client Clustering
Partitions clients into groups with similar data distributions before aggregation. FedRep can be combined with clustering to create multiple global representations, each serving a distinct patient population subgroup, while still allowing individual personalization through local heads within each cluster.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us