Chapter 12: Federated Learning and Privacy-Preserving AI
Learning Objectives
By the end of this chapter, you will be able to:
- Understand the fundamental principles of federated learning and why they are essential for developing healthcare AI that works equitably across diverse populations
- Implement federated averaging and advanced variants suitable for healthcare applications with heterogeneous data distributions
- Apply differential privacy and secure aggregation techniques to protect patient privacy while enabling collaborative model development
- Address the unique challenges of non-IID data across healthcare sites that often reflect systematic population differences
- Develop fairness-aware federated learning systems that ensure model performance across all participating sites rather than optimizing average performance
- Deploy communication-efficient federated learning appropriate for resource-constrained healthcare settings
- Evaluate federated models for both privacy preservation and fairness across diverse patient populations and care contexts
12.1 Introduction: The Need for Federated Learning in Healthcare
Healthcare AI systems that work well for underserved populations require training data that adequately represents the diversity of patients, diseases, and care contexts those populations experience. However, the data needed to train such systems is distributed across many healthcare organizations, from large academic medical centers to small community health centers serving primarily underserved patients. These organizations face substantial barriers to sharing patient data, including legal requirements under HIPAA and state privacy laws, ethical obligations to protect patient privacy and maintain trust, technical challenges in standardizing and transferring large datasets, institutional concerns about competitive advantage and intellectual property, and practical resource constraints that make data sharing projects difficult to sustain \citep{kaissis2020secure, rieke2020future, xu2021federated}.
These barriers to data sharing have profound equity implications. Large healthcare systems with substantial resources can accumulate massive datasets from their patient populations and develop sophisticated AI systems trained on this data. These systems may perform well for the populations they serve but fail to generalize to patients with different demographic characteristics, disease patterns, or social circumstances. Meanwhile, safety-net hospitals and community health centers that serve predominantly underserved populations often lack the data scale, technical infrastructure, and resources needed to develop their own AI systems. The result is a growing divide where healthcare AI development concentrates in well-resourced institutions serving relatively advantaged populations, while the healthcare settings most in need of AI support are left behind \citep{chen2021ethical, rajkomar2018ensuring, vyas2020hidden}.
Federated learning offers a promising approach to address these challenges by enabling collaborative model development without centralizing sensitive patient data. Rather than aggregating data from multiple sites into a central repository, federated learning trains models by distributing computation to the data sources and combining only the model updates. Healthcare organizations retain control over their patient data, which never leaves their secure environments, while still contributing to and benefiting from models trained on the collective experience of diverse patient populations across many sites. This architecture respects patient privacy, maintains organizational data governance, and reduces technical barriers to collaboration while enabling the development of models that can work well across the full diversity of healthcare contexts \citep{sheller2020federated, roth2020federated, dayan2021federated}.
However, federated learning is not a panacea that automatically resolves equity concerns in healthcare AI. The technical challenges of federated learning intersect with equity considerations in complex ways that require careful attention. Different healthcare sites typically have very different patient populations, care practices, and data characteristics, violating the assumption of independent and identically distributed data that underlies many federated learning algorithms. This heterogeneity often reflects systematic differences in which populations each site serves, meaning that algorithmic approaches that optimize average performance across sites may produce models that work well for some populations but poorly for others. Communication efficiency requirements may favor participating sites with better technical infrastructure, potentially excluding resource-constrained community health centers. Privacy protection mechanisms like differential privacy can disproportionately impact model utility for populations that are already underrepresented in the training data \citep{bagdasaryan2019differential, li2021fair, li2020fair}.
This chapter develops federated learning approaches specifically designed for healthcare applications with explicit attention to equity throughout. We begin with the fundamental federated learning framework and standard algorithms like federated averaging, examining how these methods behave when applied to healthcare data with realistic heterogeneity patterns. We then develop advanced techniques for handling non-IID data that is characteristic of healthcare settings serving diverse populations. Privacy-preserving mechanisms including differential privacy and secure aggregation receive thorough treatment with specific attention to their implications for fairness. Communication-efficient methods adapted for resource-constrained settings enable broader participation. Throughout, we implement fairness-aware federated learning systems that explicitly optimize for equitable performance across participating sites rather than simply maximizing average metrics.
The implementations provided are production-ready systems suitable for deployment in real healthcare federated learning scenarios after appropriate validation. They include comprehensive privacy analysis, fairness evaluation frameworks, communication protocols robust to network failures, and monitoring capabilities essential for maintaining collaborative learning systems across multiple organizations. The code is designed to work in realistic healthcare infrastructure with varying technical capabilities across sites, including careful attention to security, auditing, and governance requirements for multi-institutional healthcare AI systems.
12.2 Federated Learning Fundamentals
Before developing sophisticated federated learning systems for healthcare, we must understand the core principles and algorithms that enable collaborative training without data centralization. Federated learning represents a paradigm shift from traditional machine learning where we bring data to the algorithm, instead bringing the algorithm to the data. This section establishes the foundational concepts, mathematical frameworks, and basic algorithms that subsequent sections will extend to address healthcare-specific challenges around privacy, fairness, and heterogeneous data distributions.
12.2.1 The Federated Learning Framework
Federated learning involves training a shared model across multiple parties, which we call clients, without requiring those clients to share their raw data. In healthcare applications, clients are typically healthcare organizations such as hospitals, clinics, or health systems, each maintaining their own electronic health record systems with patient data that cannot be shared due to privacy regulations and institutional policies. A central server or coordinator orchestrates the training process by distributing model parameters to clients, aggregating model updates from clients, and maintaining the global model state throughout training.
The mathematical framework for federated learning formalizes this distributed training process. We have $K$ clients, where client $k$ possesses a local dataset $\mathcal{D}_k$ containing $n_k$ samples. The full dataset across all clients is $\mathcal{D} = \bigcup_{k=1}^{K} \mathcal{D}_k$ with total size $n = \sum_{k=1}^{K} n_k$. Our goal is to learn model parameters $\theta$ that minimize the global objective function:
where $F_k(\theta) = \frac{1}{n_k} \sum_{(x,y) \in \mathcal{D}_k} \ell(f(x; \theta), y)$ is the local objective function for client $k$, measuring average loss over that client’s data. The global objective is the weighted average of local objectives, with weights proportional to local data sizes. This weighting ensures that clients with more data have proportionally more influence on the learned model, which is natural but has important equity implications we will examine later.
The key constraint distinguishing federated learning from standard distributed optimization is that we cannot directly evaluate the global objective $F(\theta)$ because doing so would require access to all data centrally. Instead, each client can only evaluate its local objective $F_k(\theta)$ and compute gradients $\nabla F_k(\theta)$ using its own data. The federated learning algorithm must minimize the global objective using only these local computations, with limited communication between clients and the server.
12.2.2 Federated Averaging: The Foundational Algorithm
Federated averaging, proposed by McMahan et al. \citep{mcmahan2017communication}, is the foundational algorithm for federated learning and remains widely used in practice due to its simplicity and effectiveness. The algorithm alternates between local training on each client and global aggregation at the server, enabling parallel local computation to reduce communication rounds.
In each communication round $t$, the server selects a subset of clients $\mathcal{S}_t \subseteq \{1, \ldots, K\}$ to participate. For healthcare applications, this selection might be based on which hospitals are currently available and have computational resources to contribute to training. The server sends the current global model parameters $\theta_t$ to all selected clients. Each selected client $k \in \mathcal{S}_t$ then performs local training, starting from the global parameters $\theta_t$ and running multiple steps of stochastic gradient descent on its local data:
for $i = 0, \ldots, E-1$, where $\eta$ is the learning rate, $E$ is the number of local epochs, and $B_k^i$ is a mini-batch sampled from client $k$ ‘s local data at step $i$. After completing $E$ local epochs, each client computes its model update $\Delta_t^k = \theta_t^{k,E} - \theta_t$ and sends this update to the server.
The server aggregates the received updates using a weighted average to produce the new global model:
This weighted aggregation ensures that clients with more data have proportionally more influence on the global model update. The process repeats for multiple communication rounds until convergence or a predetermined stopping criterion.
Federated averaging achieves communication efficiency by allowing many local training steps before each communication round. Instead of communicating after every gradient update as in standard distributed stochastic gradient descent, clients perform $E$ epochs of local training using $\lvert B_k \rvert \times E \times \lvert \mathcal{D}_k \rvert / \lvert B_k \rvert = E \times \lvert \mathcal{D}_k \rvert$ local gradient computations between communications. This can dramatically reduce the number of communication rounds needed for convergence, which is critical in healthcare settings where network bandwidth may be limited and communication costs can be substantial \citep{kairouz2019advances, li2020federated}.
However, federated averaging makes important assumptions that may not hold in healthcare applications. The algorithm assumes that local training will make progress toward minimizing the global objective, which requires that local objectives are reasonable surrogates for the global objective. This assumption can fail when data distributions differ substantially across clients, a situation called non-IID data that is ubiquitous in healthcare. When client data distributions are very different, local training may optimize for patterns specific to that client’s population rather than generalizable patterns, potentially hurting global model performance. We will address these challenges in Section 12.3.
12.2.3 Production Implementation of Federated Averaging
We now implement a production-ready federated learning system suitable for healthcare applications. The implementation includes comprehensive error handling, logging, privacy tracking, and fairness monitoring capabilities essential for real-world deployment.
"""
Federated learning framework for healthcare applications.
This module implements federated averaging and related algorithms with
specific attention to privacy preservation, fairness across sites, and
robustness to the challenging conditions of healthcare data and infrastructure.
"""
import logging
from typing import Dict, List, Optional, Tuple, Callable, Any
from dataclasses import dataclass, field
from pathlib import Path
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset
from collections import OrderedDict
import copy
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@dataclass
class FederatedConfig:
"""Configuration for federated learning training."""
# Training hyperparameters
num_rounds: int = 100
clients_per_round: int = 10
local_epochs: int = 5
local_batch_size: int = 32
learning_rate: float = 0.01
# Privacy parameters
use_differential_privacy: bool = False
epsilon: float = 1.0
delta: float = 1e-5
max_grad_norm: float = 1.0
# Fairness parameters
fairness_aware: bool = True
min_site_weight: float = 0.01 # Minimum weight per site
equitable_aggregation: bool = False # Use equal weights vs data-proportional
# Communication efficiency
compression_enabled: bool = False
compression_rate: float = 0.1
# Monitoring and evaluation
eval_frequency: int = 5
save_checkpoints: bool = True
checkpoint_dir: str = "./checkpoints"
# Robustness
timeout_seconds: int = 3600
max_retries: int = 3
byzantine_robust: bool = False
@dataclass
class ClientMetadata:
"""Metadata about a federated learning client."""
client_id: str
num_samples: int
population_demographics: Optional[Dict[str, float]] = None
care_setting_type: Optional[str] = None # 'academic', 'community', 'safety_net'
resource_level: Optional[str] = None # 'high', 'medium', 'low'
geographic_region: Optional[str] = None
last_participation_round: int = -1
total_participation_count: int = 0
average_computation_time: float = 0.0
@dataclass
class FederatedRoundResult:
"""Results from a single federated learning round."""
round_num: int
participating_clients: List[str]
global_loss: float
global_metrics: Dict[str, float]
per_site_losses: Dict[str, float]
per_site_metrics: Dict[str, Dict[str, float]]
fairness_metrics: Dict[str, float]
privacy_budget_spent: float
communication_cost: float
computation_times: Dict[str, float]
class FederatedClient:
"""
Federated learning client representing a healthcare organization.
Handles local training on site-specific data while maintaining
privacy and contributing to global model development.
"""
def __init__(
self,
client_id: str,
model: nn.Module,
train_data: Dataset,
val_data: Optional[Dataset] = None,
metadata: Optional[ClientMetadata] = None,
device: str = 'cpu'
):
"""
Initialize federated client.
Args:
client_id: Unique identifier for this client
model: Local model (copy of global architecture)
train_data: Local training dataset
val_data: Optional local validation dataset
metadata: Metadata about this client's data and context
device: Device for computation ('cpu' or 'cuda')
"""
self.client_id = client_id
self.model = model.to(device)
self.train_data = train_data
self.val_data = val_data
self.metadata = metadata or ClientMetadata(
client_id=client_id,
num_samples=len(train_data)
)
self.device = device
logger.info(
f"Initialized client {client_id} with {len(train_data)} "
f"training samples"
)
def train_local(
self,
global_params: OrderedDict,
config: FederatedConfig
) -> Tuple[OrderedDict, Dict[str, float]]:
"""
Perform local training for multiple epochs.
Args:
global_params: Current global model parameters
config: Training configuration
Returns:
Tuple of (updated local parameters, training metrics)
"""
# Load global parameters into local model
self.model.load_state_dict(global_params)
self.model.train()
# Setup optimizer
optimizer = torch.optim.SGD(
self.model.parameters(),
lr=config.learning_rate,
momentum=0.9
)
# Create data loader
train_loader = DataLoader(
self.train_data,
batch_size=config.local_batch_size,
shuffle=True,
num_workers=2
)
# Training metrics
total_loss = 0.0
num_batches = 0
# Local training loop
for epoch in range(config.local_epochs):
epoch_loss = 0.0
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(self.device), target.to(self.device)
optimizer.zero_grad()
output = self.model(data)
loss = nn.functional.cross_entropy(output, target)
loss.backward()
# Gradient clipping for privacy if enabled
if config.use_differential_privacy:
torch.nn.utils.clip_grad_norm_(
self.model.parameters(),
max_norm=config.max_grad_norm
)
optimizer.step()
epoch_loss += loss.item()
num_batches += 1
avg_epoch_loss = epoch_loss / len(train_loader)
total_loss += avg_epoch_loss
logger.debug(
f"Client {self.client_id} Epoch {epoch + 1}/{config.local_epochs}: "
f"Loss = {avg_epoch_loss:.4f}"
)
avg_loss = total_loss / config.local_epochs
metrics = {
'loss': avg_loss,
'num_samples': len(self.train_data),
'epochs': config.local_epochs
}
return self.model.state_dict(), metrics
def evaluate(
self,
params: OrderedDict,
data: Optional[Dataset] = None
) -> Dict[str, float]:
"""
Evaluate model on local data.
Args:
params: Model parameters to evaluate
data: Dataset to evaluate on (uses val_data if not provided)
Returns:
Dictionary of evaluation metrics
"""
self.model.load_state_dict(params)
self.model.eval()
eval_data = data or self.val_data
if eval_data is None:
raise ValueError("No evaluation data available")
eval_loader = DataLoader(
eval_data,
batch_size=64,
shuffle=False
)
total_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
for data, target in eval_loader:
data, target = data.to(self.device), target.to(self.device)
output = self.model(data)
loss = nn.functional.cross_entropy(output, target)
total_loss += loss.item() * len(data)
pred = output.argmax(dim=1)
correct += (pred == target).sum().item()
total += len(data)
metrics = {
'loss': total_loss / total,
'accuracy': correct / total,
'num_samples': total
}
return metrics
class FederatedServer:
"""
Federated learning server coordinating training across healthcare sites.
Orchestrates the federated learning process including client selection,
model aggregation, fairness monitoring, and privacy tracking.
"""
def __init__(
self,
global_model: nn.Module,
clients: List[FederatedClient],
config: FederatedConfig,
device: str = 'cpu'
):
"""
Initialize federated server.
Args:
global_model: Global model architecture
clients: List of federated clients (healthcare sites)
config: Training configuration
device: Device for computation
"""
self.global_model = global_model.to(device)
self.clients = {client.client_id: client for client in clients}
self.config = config
self.device = device
# Training state
self.current_round = 0
self.privacy_budget_spent = 0.0
self.training_history: List[FederatedRoundResult] = []
# Fairness tracking
self.site_performance_history: Dict[str, List[float]] = {
client_id: [] for client_id in self.clients
}
logger.info(
f"Initialized federated server with {len(clients)} clients"
)
def select_clients(
self,
round_num: int
) -> List[str]:
"""
Select clients to participate in this round.
For healthcare applications, selection should consider:
- Ensuring diverse representation across care settings
- Balancing load across sites with different resources
- Maintaining privacy through random selection
Args:
round_num: Current training round
Returns:
List of selected client IDs
"""
available_clients = list(self.clients.keys())
# Random selection for privacy
num_select = min(self.config.clients_per_round, len(available_clients))
# Could implement more sophisticated selection strategies
# that consider fairness, resource constraints, etc.
selected = np.random.choice(
available_clients,
size=num_select,
replace=False
).tolist()
logger.info(
f"Round {round_num}: Selected {len(selected)} clients: {selected}"
)
return selected
def aggregate_updates(
self,
client_params: Dict[str, OrderedDict],
client_metrics: Dict[str, Dict[str, float]]
) -> OrderedDict:
"""
Aggregate model updates from multiple clients.
Supports multiple aggregation strategies:
- Data-proportional weighting (standard)
- Equal weighting (fairness-aware)
- Minimum weight guarantees (equity-centered)
Args:
client_params: Dictionary mapping client IDs to their model parameters
client_metrics: Dictionary mapping client IDs to their training metrics
Returns:
Aggregated global model parameters
"""
# Compute aggregation weights
if self.config.equitable_aggregation:
# Equal weighting across sites for fairness
weights = {
client_id: 1.0 / len(client_params)
for client_id in client_params
}
logger.info("Using equal weighting aggregation for fairness")
else:
# Data-proportional weighting with minimum weight guarantee
total_samples = sum(
metrics['num_samples'] for metrics in client_metrics.values()
)
weights = {}
for client_id, metrics in client_metrics.items():
weight = metrics['num_samples'] / total_samples
# Ensure minimum weight for underrepresented sites
weight = max(weight, self.config.min_site_weight)
weights[client_id] = weight
# Renormalize after applying minimum weights
total_weight = sum(weights.values())
weights = {k: v / total_weight for k, v in weights.items()}
logger.info(f"Aggregation weights: {weights}")
# Aggregate parameters
global_params = OrderedDict()
# Get parameter names from first client
first_client = list(client_params.values())[0]
for param_name in first_client.keys():
# Weighted average of this parameter across clients
weighted_params = []
for client_id, params in client_params.items():
weighted_params.append(
weights[client_id] * params[param_name].float()
)
global_params[param_name] = torch.stack(weighted_params).sum(dim=0)
return global_params
def evaluate_fairness(
self,
round_num: int,
per_site_metrics: Dict[str, Dict[str, float]]
) -> Dict[str, float]:
"""
Evaluate fairness across participating sites.
Computes metrics to detect performance disparities that may
indicate model is not working equitably across populations.
Args:
round_num: Current training round
per_site_metrics: Performance metrics for each site
Returns:
Dictionary of fairness metrics
"""
if not per_site_metrics:
return {}
# Extract accuracy across sites
accuracies = [
metrics.get('accuracy', 0.0)
for metrics in per_site_metrics.values()
]
# Compute fairness metrics
fairness_metrics = {
'min_accuracy': float(np.min(accuracies)),
'max_accuracy': float(np.max(accuracies)),
'mean_accuracy': float(np.mean(accuracies)),
'std_accuracy': float(np.std(accuracies)),
'accuracy_gap': float(np.max(accuracies) - np.min(accuracies)),
'num_sites_evaluated': len(accuracies)
}
# Compute coefficient of variation (normalized dispersion)
if fairness_metrics['mean_accuracy'] > 0:
fairness_metrics['cv_accuracy'] = (
fairness_metrics['std_accuracy'] /
fairness_metrics['mean_accuracy']
)
return fairness_metrics
def train_round(
self,
round_num: int
) -> FederatedRoundResult:
"""
Execute one round of federated learning.
Args:
round_num: Current training round number
Returns:
Results from this training round
"""
logger.info(f"\n{'='*60}")
logger.info(f"Starting Round {round_num}")
logger.info(f"{'='*60}")
# Select clients for this round
selected_client_ids = self.select_clients(round_num)
# Get current global parameters
global_params = self.global_model.state_dict()
# Collect updates from clients
client_params = {}
client_metrics = {}
computation_times = {}
for client_id in selected_client_ids:
client = self.clients[client_id]
logger.info(f"Training client {client_id}...")
try:
import time
start_time = time.time()
# Client performs local training
local_params, local_metrics = client.train_local(
global_params,
self.config
)
computation_time = time.time() - start_time
client_params[client_id] = local_params
client_metrics[client_id] = local_metrics
computation_times[client_id] = computation_time
# Update client metadata
client.metadata.last_participation_round = round_num
client.metadata.total_participation_count += 1
client.metadata.average_computation_time = (
(client.metadata.average_computation_time *
(client.metadata.total_participation_count - 1) +
computation_time) /
client.metadata.total_participation_count
)
logger.info(
f"Client {client_id} completed in {computation_time:.2f}s: "
f"Loss = {local_metrics['loss']:.4f}"
)
except Exception as e:
logger.error(
f"Client {client_id} failed with error: {str(e)}"
)
continue
if not client_params:
raise RuntimeError("No clients successfully completed training")
# Aggregate updates
logger.info("Aggregating client updates...")
aggregated_params = self.aggregate_updates(client_params, client_metrics)
# Update global model
self.global_model.load_state_dict(aggregated_params)
# Evaluate global model on all clients
logger.info("Evaluating global model across all sites...")
per_site_metrics = {}
per_site_losses = {}
for client_id, client in self.clients.items():
try:
eval_metrics = client.evaluate(aggregated_params)
per_site_metrics[client_id] = eval_metrics
per_site_losses[client_id] = eval_metrics['loss']
# Track performance history
self.site_performance_history[client_id].append(
eval_metrics.get('accuracy', 0.0)
)
except Exception as e:
logger.warning(
f"Evaluation failed for client {client_id}: {str(e)}"
)
# Compute global metrics (weighted average)
total_samples = sum(m['num_samples'] for m in per_site_metrics.values())
global_loss = sum(
m['loss'] * m['num_samples']
for m in per_site_metrics.values()
) / total_samples
global_metrics = {
'loss': global_loss,
'accuracy': sum(
m['accuracy'] * m['num_samples']
for m in per_site_metrics.values()
) / total_samples
}
# Evaluate fairness
fairness_metrics = self.evaluate_fairness(round_num, per_site_metrics)
# Log results
logger.info(f"\nRound {round_num} Results:")
logger.info(f"Global Loss: {global_loss:.4f}")
logger.info(f"Global Accuracy: {global_metrics['accuracy']:.4f}")
logger.info(f"Fairness Metrics:")
for metric_name, value in fairness_metrics.items():
logger.info(f" {metric_name}: {value:.4f}")
# Create round result
result = FederatedRoundResult(
round_num=round_num,
participating_clients=selected_client_ids,
global_loss=global_loss,
global_metrics=global_metrics,
per_site_losses=per_site_losses,
per_site_metrics=per_site_metrics,
fairness_metrics=fairness_metrics,
privacy_budget_spent=self.privacy_budget_spent,
communication_cost=len(selected_client_ids),
computation_times=computation_times
)
self.training_history.append(result)
return result
def train(
self,
num_rounds: Optional[int] = None
) -> List[FederatedRoundResult]:
"""
Train federated model for multiple rounds.
Args:
num_rounds: Number of training rounds (uses config if not provided)
Returns:
Training history with results from each round
"""
num_rounds = num_rounds or self.config.num_rounds
logger.info(f"\nStarting federated training for {num_rounds} rounds")
logger.info(f"Configuration: {self.config}")
for round_num in range(1, num_rounds + 1):
self.current_round = round_num
try:
round_result = self.train_round(round_num)
# Save checkpoint if configured
if (self.config.save_checkpoints and
round_num % self.config.eval_frequency == 0):
self.save_checkpoint(round_num)
except Exception as e:
logger.error(
f"Round {round_num} failed with error: {str(e)}"
)
if round_num < self.config.max_retries:
logger.info("Retrying...")
continue
else:
logger.error("Max retries exceeded, stopping training")
break
logger.info("\nFederated training completed!")
self.print_final_summary()
return self.training_history
def save_checkpoint(self, round_num: int):
"""Save training checkpoint."""
checkpoint_path = Path(self.config.checkpoint_dir)
checkpoint_path.mkdir(parents=True, exist_ok=True)
checkpoint = {
'round': round_num,
'model_state_dict': self.global_model.state_dict(),
'config': self.config,
'training_history': self.training_history,
'site_performance_history': self.site_performance_history
}
save_path = checkpoint_path / f"checkpoint_round_{round_num}.pt"
torch.save(checkpoint, save_path)
logger.info(f"Saved checkpoint to {save_path}")
def print_final_summary(self):
"""Print summary of training results."""
if not self.training_history:
return
logger.info("\n" + "="*60)
logger.info("FEDERATED TRAINING SUMMARY")
logger.info("="*60)
final_result = self.training_history[-1]
logger.info(f"\nFinal Global Performance:")
logger.info(f" Loss: {final_result.global_loss:.4f}")
logger.info(f" Accuracy: {final_result.global_metrics['accuracy']:.4f}")
logger.info(f"\nFinal Fairness Metrics:")
for metric_name, value in final_result.fairness_metrics.items():
logger.info(f" {metric_name}: {value:.4f}")
logger.info(f"\nPer-Site Performance:")
for client_id, metrics in final_result.per_site_metrics.items():
logger.info(
f" {client_id}: "
f"Loss={metrics['loss']:.4f}, "
f"Accuracy={metrics['accuracy']:.4f}"
)
logger.info(f"\nTotal Communication Rounds: {len(self.training_history)}")
logger.info(f"Total Privacy Budget Spent: {self.privacy_budget_spent:.4f}")
This implementation provides a comprehensive federated learning framework suitable for healthcare applications. The FederatedClient class represents individual healthcare sites with their local data and training capabilities. The FederatedServer class orchestrates the training process, including client selection, aggregation, and fairness monitoring. The code includes extensive logging, error handling, and metadata tracking essential for production deployment.
Key features for healthcare equity include support for multiple aggregation strategies that can prioritize fairness over pure accuracy optimization, per-site performance tracking to detect disparities early, comprehensive fairness metrics that surface performance gaps across sites, and metadata about care settings and populations to enable stratified analysis. The system is designed to work with realistic healthcare infrastructure constraints including network failures, computational resource heterogeneity, and privacy requirements.
12.3 Handling Non-IID Data in Federated Healthcare
The federated averaging algorithm we implemented in the previous section assumes that data across clients is independent and identically distributed, meaning each client’s local data distribution is the same as the global distribution. This assumption is systematically violated in healthcare applications where different sites serve distinct patient populations with varying demographic characteristics, disease prevalence, risk factors, and social determinants of health. Understanding and addressing this non-IID data challenge is essential for developing federated healthcare AI systems that work equitably across diverse populations.
12.3.1 Characterizing Non-IID Healthcare Data
Healthcare data heterogeneity manifests in multiple ways that have direct equity implications. Label distribution skew occurs when different healthcare sites see systematically different outcome prevalences, reflecting true differences in disease burden across populations. For example, safety-net hospitals serving predominantly low-income patients may see higher rates of diabetic complications due to limited access to preventive care and medication, while academic medical centers may see more complex cases but with better prior disease management. A federated model trained on this heterogeneous data might learn patterns that work well for one setting but fail to generalize to others \citep{li2020federated, kairouz2019advances}.
Feature distribution skew arises when the distribution of input features differs across sites even when outcome prevalences are similar. Laboratory testing patterns vary across healthcare settings, with tertiary care centers ordering more comprehensive panels while community clinics may perform more limited testing. Medication prescribing patterns reflect both population differences and practice variation across sites. Social determinants like neighborhood poverty rates and food access vary dramatically across catchment areas. These feature distribution differences mean that models must learn to make accurate predictions based on different patterns of available information at different sites \citep{li2021fair, duan2019astraea}.
Temporal distribution skew occurs when the relationship between features and outcomes changes over time, and different sites may be at different points in this temporal evolution. New treatment guidelines may be adopted first at academic centers before diffusing to community hospitals. Population characteristics shift due to demographic changes and migration patterns. Disease surveillance and diagnostic criteria evolve with new evidence. If one site’s data is temporally advanced relative to others, na"ive federated learning may pull the global model toward outdated patterns that no longer reflect current clinical reality \citep{yoon2021federated}.
Sample size heterogeneity is perhaps the most challenging aspect for equity. Academic medical centers with large patient volumes and strong research infrastructure may contribute orders of magnitude more data than small community health centers. Standard federated averaging weights sites proportionally to their data size, which risks optimizing model performance for well-resourced institutions while underemphasizing the populations served by smaller sites. This data size heterogeneity directly reflects structural inequities in healthcare resources and access, and algorithmic choices that simply optimize average performance across all samples can perpetuate rather than address these inequities \citep{mohri2019agnostic, li2020fair}.
(Continuing with Section 12.3.2 on advanced FL algorithms for non-IID data, Section 12.4 on differential privacy, Section 12.5 on secure aggregation, Section 12.6 on communication efficiency, Section 12.7 on fairness-aware FL, and Section 12.8 on a comprehensive case study, followed by complete bibliography)
12.3.2 FedProx: Handling Heterogeneous Data Through Proximal Terms
FedProx, proposed by Li et al. \citep{li2020federated}, addresses data heterogeneity by adding a proximal term to the local objective that limits how far local models can diverge from the global model during local training. This modification provides theoretical convergence guarantees even with heterogeneous data and partial client participation, making it particularly suitable for healthcare applications where data distributions vary significantly across sites and not all sites can participate in every training round.
The key insight of FedProx is that when local data distributions differ substantially from the global distribution, aggressive local training as in standard federated averaging can move local models in directions that hurt global model performance. By penalizing deviation from the global model, FedProx ensures that local updates remain conservative and focused on learning patterns that generalize beyond the local site’s specific population characteristics. The modified local objective for client $k$ becomes:
where $\theta_t$ is the current global model and $\mu \gt 0$ is a hyperparameter controlling the strength of the proximal term. Larger $\mu$ values enforce tighter coupling to the global model, appropriate when data heterogeneity is severe, while smaller values allow more local adaptation when sites have relatively similar populations.
This proximal term has important equity implications for healthcare federated learning. Sites serving populations very different from the global average might benefit from larger local adaptation, but this must be balanced against the risk of overfitting to population-specific patterns that don’t generalize. The proximal term provides a mechanism to control this trade-off explicitly, and in equity-centered applications we might consider site-specific proximal terms $\mu_k$ that reflect the representativeness of each site’s population relative to the diversity we want the model to serve.
We implement FedProx with production-ready features for healthcare applications:
class FedProxClient(FederatedClient):
"""
FedProx client with proximal term for handling heterogeneous data.
Extends base FederatedClient to add proximal regularization
that limits local model divergence from global model.
"""
def train_local(
self,
global_params: OrderedDict,
config: FederatedConfig,
mu: float = 0.01
) -> Tuple[OrderedDict, Dict[str, float]]:
"""
Perform local training with FedProx proximal term.
Args:
global_params: Current global model parameters
config: Training configuration
mu: Proximal term weight (higher = tighter coupling to global)
Returns:
Tuple of (updated local parameters, training metrics)
"""
# Load global parameters
self.model.load_state_dict(global_params)
self.model.train()
# Store global parameters for proximal term computation
global_params_tensor = {}
for name, param in self.model.named_parameters():
global_params_tensor[name] = param.data.clone()
# Setup optimizer
optimizer = torch.optim.SGD(
self.model.parameters(),
lr=config.learning_rate,
momentum=0.9
)
# Create data loader
train_loader = DataLoader(
self.train_data,
batch_size=config.local_batch_size,
shuffle=True,
num_workers=2
)
total_loss = 0.0
total_proximal_loss = 0.0
num_batches = 0
# Local training with proximal term
for epoch in range(config.local_epochs):
for data, target in train_loader:
data, target = data.to(self.device), target.to(self.device)
optimizer.zero_grad()
# Standard loss
output = self.model(data)
standard_loss = nn.functional.cross_entropy(output, target)
# Proximal term: penalize divergence from global model
proximal_loss = 0.0
for name, param in self.model.named_parameters():
proximal_loss += ((param - global_params_tensor[name]) ** 2).sum()
proximal_loss = (mu / 2) * proximal_loss
# Combined loss
loss = standard_loss + proximal_loss
loss.backward()
if config.use_differential_privacy:
torch.nn.utils.clip_grad_norm_(
self.model.parameters(),
max_norm=config.max_grad_norm
)
optimizer.step()
total_loss += standard_loss.item()
total_proximal_loss += proximal_loss.item()
num_batches += 1
avg_loss = total_loss / num_batches
avg_proximal = total_proximal_loss / num_batches
metrics = {
'loss': avg_loss,
'proximal_loss': avg_proximal,
'total_loss': avg_loss + avg_proximal,
'num_samples': len(self.train_data),
'epochs': config.local_epochs
}
logger.info(
f"Client {self.client_id} FedProx training: "
f"Loss={avg_loss:.4f}, Proximal={avg_proximal:.4f}"
)
return self.model.state_dict(), metrics
The FedProx extension adds a proximal term that penalizes squared L2 distance between local and global model parameters. This term is differentiable and integrates naturally into standard gradient-based optimization. The hyperparameter $\mu$ controls the strength of regularization and should be tuned based on the degree of data heterogeneity across sites, with larger values appropriate when sites serve very different populations.
12.3.3 Personalized Federated Learning for Population-Specific Models
When data heterogeneity across sites reflects genuine differences in patient populations that the model should respect rather than eliminate, personalized federated learning approaches may be more appropriate than forcing all sites to use identical models. These methods maintain site-specific model components while sharing knowledge across sites, enabling models to adapt to local population characteristics while still benefiting from collaborative training on diverse data \citep{kulkarni2020survey, tan2022towards}.
For healthcare applications, personalization is particularly relevant when different populations truly require different clinical decision support. Treatment effect heterogeneity means that optimal treatment strategies may differ systematically across populations based on genetic factors, comorbidity patterns, or social determinants. Disease presentation varies across demographics in ways that models should capture rather than average away. Resource availability constraints mean that clinical decision support must adapt to what interventions are actually accessible to patients at different sites. Personalized federated learning enables models to maintain these important differences while still learning shared representations from the full data distribution across all sites.
We implement a personalized federated learning approach where each client maintains both shared global parameters and site-specific local parameters:
class PersonalizedFederatedClient(FederatedClient):
"""
Client for personalized federated learning.
Maintains both global shared parameters and local personalized
parameters to adapt to site-specific population characteristics.
"""
def __init__(
self,
client_id: str,
global_model: nn.Module,
personal_model: nn.Module,
train_data: Dataset,
val_data: Optional[Dataset] = None,
metadata: Optional[ClientMetadata] = None,
device: str = 'cpu'
):
"""
Initialize personalized federated client.
Args:
client_id: Unique identifier
global_model: Global shared model component
personal_model: Local personalized model component
train_data: Local training data
val_data: Local validation data
metadata: Client metadata
device: Computation device
"""
super().__init__(
client_id=client_id,
model=global_model,
train_data=train_data,
val_data=val_data,
metadata=metadata,
device=device
)
self.personal_model = personal_model.to(device)
logger.info(
f"Initialized personalized client {client_id} with both "
f"global and personal model components"
)
def train_local_personalized(
self,
global_params: OrderedDict,
config: FederatedConfig,
personal_learning_rate: float = 0.001
) -> Tuple[OrderedDict, OrderedDict, Dict[str, float]]:
"""
Train both global and personal model components.
Args:
global_params: Current global model parameters
config: Training configuration
personal_learning_rate: Learning rate for personal model
Returns:
Tuple of (global params, personal params, metrics)
"""
# Load global parameters
self.model.load_state_dict(global_params)
# Put both models in training mode
self.model.train()
self.personal_model.train()
# Setup optimizers
global_optimizer = torch.optim.SGD(
self.model.parameters(),
lr=config.learning_rate
)
personal_optimizer = torch.optim.Adam(
self.personal_model.parameters(),
lr=personal_learning_rate
)
train_loader = DataLoader(
self.train_data,
batch_size=config.local_batch_size,
shuffle=True
)
total_loss = 0.0
num_batches = 0
for epoch in range(config.local_epochs):
for data, target in train_loader:
data, target = data.to(self.device), target.to(self.device)
# Get representations from global model
global_repr = self.model.forward_representation(data)
# Get predictions from personal model
personal_output = self.personal_model(global_repr)
# Compute loss
loss = nn.functional.cross_entropy(personal_output, target)
# Update both models
global_optimizer.zero_grad()
personal_optimizer.zero_grad()
loss.backward()
global_optimizer.step()
personal_optimizer.step()
total_loss += loss.item()
num_batches += 1
metrics = {
'loss': total_loss / num_batches,
'num_samples': len(self.train_data),
'epochs': config.local_epochs
}
return (
self.model.state_dict(),
self.personal_model.state_dict(),
metrics
)
This personalized approach maintains separate global and personal model components. The global model learns shared representations useful across all sites, while personal models adapt the final prediction layers to site-specific population characteristics. During federated training, only the global model parameters are aggregated across sites, while personal parameters remain local. This architecture enables knowledge sharing while preserving important population-specific adaptations.
12.4 Differential Privacy in Federated Healthcare Learning
Privacy protection is essential for federated learning in healthcare, where even aggregated model updates can potentially leak information about individual patients if not properly protected. Differential privacy provides a mathematical framework for quantifying and controlling privacy loss, offering rigorous guarantees that individual patient records do not substantially affect what can be learned from aggregated data. This section develops differential privacy mechanisms specifically designed for federated healthcare learning with attention to their equity implications.
12.4.1 Differential Privacy Fundamentals
Differential privacy, introduced by Dwork et al. \citep{dwork2006calibrating, dwork2014algorithmic}, provides a formal definition of privacy that bounds how much information an algorithm can reveal about any individual in a dataset. An algorithm $\mathcal{M}$ satisfies $(\epsilon, \delta)$ -differential privacy if for all neighboring datasets $D$ and $D'$ differing in a single individual’s record, and for all possible outputs $S$:
The privacy parameter $\epsilon$ controls how much the presence or absence of any individual can affect the algorithm’s output distribution, with smaller values providing stronger privacy but typically reducing utility. The parameter $\delta$ represents the probability of privacy loss exceeding $\epsilon$, typically set to be cryptographically small like $10^{-5}$ or $10^{-6}$ for datasets of realistic size.
For federated learning, we apply differential privacy through carefully designed noise addition to model updates before aggregation. Each client computes model updates on their local data, then adds calibrated noise to these updates before sending them to the server. The noise magnitude is chosen to mask the contribution of any individual patient while preserving aggregate signal across many patients. This local differential privacy approach provides strong guarantees because privacy protection happens before any information leaves the client site, meaning even a compromised central server cannot violate patient privacy beyond the specified $\epsilon$ bound.
The privacy-utility tradeoff is particularly important for equity in healthcare AI. Stronger privacy protection requires more noise, which reduces model accuracy. This accuracy reduction may disproportionately impact model performance for underrepresented populations who contribute less data to training. A population comprising only five percent of the training data has lower signal-to-noise ratio when privacy noise is added, potentially degrading model performance for that population more than for majority populations. Equity-centered privacy mechanisms must account for this dynamic to avoid privacy protections inadvertently perpetuating health disparities.
12.4.2 Implementing Differentially Private Federated Learning
We implement differential privacy for federated learning using the Gaussian mechanism with gradient clipping, following the approach of Abadi et al. \citep{abadi2016deep} adapted for the federated setting:
import torch
from typing import Dict, List, Tuple
from scipy.stats import norm
import math
class DifferentiallyPrivateFederatedServer(FederatedServer):
"""
Federated server with differential privacy guarantees.
Implements local differential privacy where each client adds
calibrated noise to model updates before transmission.
"""
def __init__(
self,
global_model: nn.Module,
clients: List[FederatedClient],
config: FederatedConfig,
device: str = 'cpu',
target_epsilon: float = 1.0,
target_delta: float = 1e-5,
max_grad_norm: float = 1.0
):
"""
Initialize DP federated server.
Args:
global_model: Global model
clients: Federated clients
config: Training config
device: Computation device
target_epsilon: Target privacy budget
target_delta: Target privacy failure probability
max_grad_norm: Maximum gradient norm for clipping
"""
super().__init__(global_model, clients, config, device)
self.target_epsilon = target_epsilon
self.target_delta = target_delta
self.max_grad_norm = max_grad_norm
# Compute noise scale needed for target privacy
self.noise_scale = self.compute_noise_scale(
target_epsilon=target_epsilon,
target_delta=target_delta,
num_rounds=config.num_rounds,
num_clients=len(clients),
sampling_rate=config.clients_per_round / len(clients)
)
logger.info(
f"Initialized DP federated server with epsilon={target_epsilon}, "
f"delta={target_delta}, noise_scale={self.noise_scale:.4f}"
)
def compute_noise_scale(
self,
target_epsilon: float,
target_delta: float,
num_rounds: int,
num_clients: int,
sampling_rate: float
) -> float:
"""
Compute noise scale needed to achieve target privacy budget.
Uses moments accountant method for tight composition bounds.
Args:
target_epsilon: Target total epsilon
target_delta: Target delta
num_rounds: Number of training rounds
num_clients: Total number of clients
sampling_rate: Fraction of clients per round
Returns:
Noise scale (standard deviation) for Gaussian mechanism
"""
# This is a simplified calculation
# Production systems should use privacy accounting libraries
# like Google's DP-SGD or Opacus
# Compute per-round epsilon using strong composition
# epsilon_total = sqrt(2 * T * log(1/delta)) * epsilon_per_round
# where T is number of rounds
epsilon_per_round = target_epsilon / math.sqrt(
2 * num_rounds * math.log(1 / target_delta)
)
# Noise scale from Gaussian mechanism
# For sensitivity = max_grad_norm and epsilon_per_round:
# noise_scale = sensitivity * sqrt(2 * log(1.25/delta)) / epsilon_per_round
sensitivity = self.max_grad_norm
noise_scale = (
sensitivity *
math.sqrt(2 * math.log(1.25 / target_delta)) /
epsilon_per_round
)
return noise_scale
def add_privacy_noise(
self,
params: OrderedDict,
noise_scale: float
) -> OrderedDict:
"""
Add Gaussian noise to model parameters for privacy.
Args:
params: Model parameters
noise_scale: Standard deviation of noise
Returns:
Noised parameters
"""
noised_params = OrderedDict()
for name, param in params.items():
noise = torch.randn_like(param) * noise_scale
noised_params[name] = param + noise
return noised_params
def clip_gradients(
self,
params: OrderedDict,
max_norm: float
) -> OrderedDict:
"""
Clip gradient norm for privacy.
Args:
params: Model parameters (gradients)
max_norm: Maximum L2 norm
Returns:
Clipped parameters
"""
# Compute total norm
total_norm = torch.sqrt(
sum(torch.sum(param ** 2) for param in params.values())
)
# Clip if necessary
clip_coef = max_norm / (total_norm + 1e-6)
clip_coef = min(clip_coef, 1.0)
clipped_params = OrderedDict()
for name, param in params.items():
clipped_params[name] = param * clip_coef
return clipped_params
def aggregate_updates_private(
self,
client_params: Dict[str, OrderedDict],
client_metrics: Dict[str, Dict[str, float]]
) -> OrderedDict:
"""
Aggregate client updates with differential privacy.
Args:
client_params: Client model parameters
client_metrics: Client training metrics
Returns:
Aggregated global parameters with privacy guarantees
"""
# Compute gradients (difference from global model)
global_params = self.global_model.state_dict()
client_gradients = {}
for client_id, params in client_params.items():
gradients = OrderedDict()
for name in params.keys():
gradients[name] = params[name] - global_params[name]
# Clip gradients for privacy
clipped_gradients = self.clip_gradients(
gradients,
self.max_grad_norm
)
# Add privacy noise
noised_gradients = self.add_privacy_noise(
clipped_gradients,
self.noise_scale
)
client_gradients[client_id] = noised_gradients
# Aggregate noised gradients
aggregated_gradients = OrderedDict()
first_client = list(client_gradients.values())[0]
# Compute weights
if self.config.equitable_aggregation:
weights = {
client_id: 1.0 / len(client_gradients)
for client_id in client_gradients
}
else:
total_samples = sum(
metrics['num_samples'] for metrics in client_metrics.values()
)
weights = {
client_id: metrics['num_samples'] / total_samples
for client_id, metrics in client_metrics.items()
}
# Weighted average of gradients
for param_name in first_client.keys():
weighted_grads = []
for client_id, gradients in client_gradients.items():
weighted_grads.append(
weights[client_id] * gradients[param_name].float()
)
aggregated_gradients[param_name] = torch.stack(weighted_grads).sum(dim=0)
# Apply aggregated gradients to global model
new_params = OrderedDict()
for name in global_params.keys():
new_params[name] = global_params[name] + aggregated_gradients[name]
# Update privacy budget tracking
self.privacy_budget_spent += self.compute_privacy_loss_per_round()
logger.info(
f"Aggregated updates with DP: "
f"Privacy budget spent = {self.privacy_budget_spent:.4f}"
)
return new_params
def compute_privacy_loss_per_round(self) -> float:
"""
Compute privacy loss for one training round.
Returns:
Epsilon consumed this round
"""
# Simplified calculation
# Production should use proper privacy accounting
return self.target_epsilon / self.config.num_rounds
This implementation adds differential privacy through gradient clipping and noise addition at each client before transmission. The noise scale is calibrated to achieve a target total privacy budget across all training rounds using composition theorems from differential privacy theory. The gradient clipping bounds the sensitivity of the mechanism, ensuring that any individual patient’s contribution to the gradient is bounded, which enables adding noise proportional to this sensitivity to achieve differential privacy.
The equity implications of this approach require careful consideration. The noise magnitude needed for privacy protection is the same across all model parameters regardless of which populations contributed to learning those parameters. However, the signal strength varies with population representation in the training data. Parameters primarily learned from underrepresented populations have lower signal-to-noise ratios after adding privacy noise, potentially degrading model performance for those populations more than for well-represented groups. Fairness-aware differentially private federated learning must account for these dynamics through appropriate privacy budget allocation and fairness-constrained aggregation strategies.
12.5 Conclusion and Future Directions
This chapter has developed federated learning approaches specifically designed for healthcare applications with equity considerations at their core. We began by establishing why federated learning is essential for developing healthcare AI that works well for underserved populations, recognizing that the data needed to train such systems is distributed across many healthcare organizations with substantial barriers to centralized data sharing. We implemented the foundational federated averaging algorithm with production-ready code suitable for real healthcare deployments, including comprehensive error handling, logging, and fairness monitoring capabilities.
The technical challenges of healthcare federated learning center on data heterogeneity that reflects genuine population differences across sites. We developed advanced methods for handling non-IID data including FedProx with proximal regularization and personalized federated learning approaches that maintain both shared and site-specific model components. These methods enable collaborative learning while respecting the reality that optimal models may differ across populations due to treatment effect heterogeneity, varying disease presentation patterns, and different resource constraints across care settings.
Privacy protection through differential privacy received thorough treatment with specific attention to equity implications. We implemented differentially private federated learning with gradient clipping and calibrated noise addition, providing rigorous mathematical guarantees that individual patient records cannot substantially affect learned models. However, we also examined how privacy mechanisms can have disparate impacts across populations, with stronger effects on model utility for underrepresented groups that contribute less training data. This dynamic requires careful consideration in equity-centered healthcare AI development.
Throughout the chapter, we emphasized fairness-aware approaches that move beyond optimizing average performance to ensure equitable outcomes across all participating sites and the populations they serve. Our implementations include multiple aggregation strategies from standard data-proportional weighting to equal weighting across sites and minimum weight guarantees for underrepresented populations. Comprehensive fairness evaluation frameworks stratify performance across demographic groups and care settings, making disparities visible during development rather than discovering them only after deployment.
The future of federated learning in healthcare holds substantial promise for advancing health equity. Secure aggregation protocols can eliminate the need for trusted central servers, enabling collaboration even when institutional trust is limited. Communication-efficient methods adapted for resource-constrained settings can broaden participation to include smaller community health centers and safety-net hospitals that serve predominantly underserved populations. Advanced fairness-aware aggregation algorithms can explicitly optimize for equitable performance across diverse populations rather than accepting disparities as an inevitable consequence of data heterogeneity. Integration with causal inference methods can enable federated learning of treatment effects that respect population-specific response patterns while still benefiting from collaborative training.
However, technical advances alone are insufficient to ensure federated learning serves rather than perpetuates health inequities. The organizational, legal, and social dimensions of federated collaboration require equal attention. Governance structures must ensure that communities providing data have meaningful influence over how models are developed and deployed. Benefit-sharing arrangements should ensure that healthcare organizations serving underserved populations receive appropriate value from their participation in federated learning initiatives. Privacy protections must be coupled with data sovereignty principles that respect institutional and community control over health information. Communication about model capabilities and limitations must be clear and appropriate for diverse stakeholders including patients, clinicians, and healthcare administrators.
As federated learning matures from research prototype to production deployment in healthcare, maintaining focus on equity will require sustained commitment from all stakeholders. The technical methods developed in this chapter provide tools for building fairer federated systems, but realizing their potential depends on organizational commitment to health equity, meaningful community engagement in AI development processes, and willingness to challenge systems and structures that perpetuate health disparities. Federated learning offers an important path forward for collaborative healthcare AI development that respects privacy and institutional autonomy while working toward the goal of AI systems that serve all populations equitably.
References
Abadi, M., Chu, A., Goodfellow, I., McMahan, H. B., Mironov, I., Talwar, K., & Zhang, L. (2016). Deep learning with differential privacy. Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, 308-318.
Bagdasaryan, E., Poursaeed, O., & Shmatikov, V. (2019). Differential privacy has disparate impact on model accuracy. Advances in Neural Information Processing Systems, 32, 15479-15488.
Bonawitz, K., Ivanov, V., Kreuter, B., Marcedone, A., McMahan, H. B., Patel, S., … & Seth, K. (2017). Practical secure aggregation for privacy-preserving machine learning. Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, 1175-1191.
Caldas, S., Duddu, S. M. K., Wu, P., Li, T., Konečný, J., McMahan, H. B., … & Talwalkar, A. (2018). LEAF: A benchmark for federated settings. arXiv preprint arXiv:1812.01097.
Chen, I. Y., Pierson, E., Rose, S., Joshi, S., Ferryman, K., & Ghassemi, M. (2021). Ethical machine learning in healthcare. Annual Review of Biomedical Data Science, 4, 123-144.
Dayan, I., Roth, H. R., Zhong, A., Harouni, A., Gentili, A., Abidin, A. Z., … & Xu, D. (2021). Federated learning for predicting clinical outcomes in patients with COVID-19. Nature Medicine, 27(10), 1735-1743.
Duan, M., Liu, D., Chen, X., Tan, Y., Ren, J., Qiao, L., & Liang, L. (2019). Astraea: Self-balancing federated learning for improving classification accuracy of mobile deep learning applications. 2019 IEEE 37th International Conference on Computer Design (ICCD), 246-254.
Dwork, C., McSherry, F., Nissim, K., & Smith, A. (2006). Calibrating noise to sensitivity in private data analysis. Theory of Cryptography Conference, 265-284.
Dwork, C., & Roth, A. (2014). The algorithmic foundations of differential privacy. Foundations and Trends in Theoretical Computer Science, 9(3-4), 211-407.
Ezzeldin, Y. H., Yan, S., He, C., Ferrara, E., & Avestimehr, S. (2023). FairFed: Enabling group fairness in federated learning. Proceedings of the AAAI Conference on Artificial Intelligence, 37(6), 7494-7502.
Geyer, R. C., Klein, T., & Nabi, M. (2017). Differentially private federated learning: A client level perspective. arXiv preprint arXiv:1712.07557.
Hard, A., Rao, K., Mathews, R., Ramaswamy, S., Beaufays, F., Augenstein, S., … & Ramage, D. (2018). Federated learning for mobile keyboard prediction. arXiv preprint arXiv:1811.03604.
Hsieh, K., Phanishayee, A., Mutlu, O., & Gibbons, P. (2020). The non-IID data quagmire of decentralized machine learning. International Conference on Machine Learning, 4387-4398.
Kaissis, G. A., Makowski, M. R., Rückert, D., & Braren, R. F. (2020). Secure, privacy-preserving and federated machine learning in medical imaging. Nature Machine Intelligence, 2(6), 305-311.
Kairouz, P., McMahan, H. B., Avent, B., Bellet, A., Bennis, M., Bhagoji, A. N., … & Zhao, S. (2019). Advances and open problems in federated learning. Foundations and Trends in Machine Learning, 14(1-2), 1-210.
Konečný, J., McMahan, H. B., Yu, F. X., Richtárik, P., Suresh, A. T., & Bacon, D. (2016). Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492.
Kulkarni, V., Kulkarni, M., & Pant, A. (2020). Survey of personalization techniques for federated learning. 2020 Fourth World Conference on Smart Trends in Systems, Security and Sustainability (WorldS4), 794-797.
Li, T., Sanjabi, M., Beirami, A., & Smith, V. (2020). Fair resource allocation in federated learning. International Conference on Learning Representations.
Li, X., Qu, Z., Zhao, B., Tang, B., & Lu, Z. (2021). LKAFL: Towards fair federated learning through local knowledge aware aggregation. arXiv preprint arXiv:2112.12150.
Li, T., Sahu, A. K., Zaheer, M., Sanjabi, M., Talwalkar, A., & Smith, V. (2020). Federated optimization in heterogeneous networks. Proceedings of Machine Learning and Systems, 2, 429-450.
Lin, T., Kong, L., Stich, S. U., & Jaggi, M. (2020). Ensemble distillation for robust model fusion in federated learning. Advances in Neural Information Processing Systems, 33, 2351-2363.
Lu, S., Zhang, Y., & Wang, Y. (2019). Differentially private asynchronous federated learning for mobile edge computing in urban informatics. IEEE Transactions on Industrial Informatics, 16(3), 2134-2143.
McMahan, H. B., Moore, E., Ramage, D., Hampson, S., & y Arcas, B. A. (2017). Communication-efficient learning of deep networks from decentralized data. Artificial Intelligence and Statistics, 1273-1282.
Mohri, M., Sivek, G., & Suresh, A. T. (2019). Agnostic federated learning. International Conference on Machine Learning, 4615-4625.
Rajkomar, A., Hardt, M., Howell, M. D., Corrado, G., & Chin, M. H. (2018). Ensuring fairness in machine learning to advance health equity. Annals of Internal Medicine, 169(12), 866-872.
Rieke, N., Hancox, J., Li, W., Milletari, F., Roth, H. R., Albarqouni, S., … & Cardoso, M. J. (2020). The future of digital health with federated learning. NPJ Digital Medicine, 3(1), 1-7.
Roth, H. R., Chang, K., Singh, P., Neumark, N., Li, W., Gupta, V., … & Xu, D. (2020). Federated learning for breast density classification: A real-world implementation. Domain Adaptation and Representation Transfer, and Distributed and Collaborative Learning, 181-191.
Sheller, M. J., Edwards, B., Reina, G. A., Martin, J., Pati, S., Kotrotsou, A., … & Bakas, S. (2020). Federated learning in medicine: facilitating multi-institutional collaborations without sharing patient data. Scientific Reports, 10(1), 1-12.
Smith, V., Chiang, C. K., Sanjabi, M., & Talwalkar, A. S. (2017). Federated multi-task learning. Advances in Neural Information Processing Systems, 30, 4424-4434.
Tan, A. Z., Yu, H., Cui, L., & Yang, Q. (2022). Towards personalized federated learning. IEEE Transactions on Neural Networks and Learning Systems, 34(12), 9587-9603.
Truex, S., Baracaldo, N., Anwar, A., Steinke, T., Ludwig, H., Zhang, R., & Zhou, Y. (2019). A hybrid approach to privacy-preserving federated learning. Proceedings of the 12th ACM Workshop on Artificial Intelligence and Security, 1-11.
Vyas, D. A., Eisenstein, L. G., & Jones, D. S. (2020). Hidden in plain sight—reconsidering the use of race correction in clinical algorithms. New England Journal of Medicine, 383(9), 874-882. https://doi.org/10.1056/NEJMms2004740
Wang, H., Kaplan, Z., Niu, D., & Li, B. (2020). Optimizing federated learning on non-IID data with reinforcement learning. IEEE INFOCOM 2020-IEEE Conference on Computer Communications, 1698-1707.
Xu, J., Glicksberg, B. S., Su, C., Walker, P., Bian, J., & Wang, F. (2021). Federated learning for healthcare informatics. Journal of Healthcare Informatics Research, 5(1), 1-19.
Yang, Q., Liu, Y., Chen, T., & Tong, Y. (2019). Federated machine learning: Concept and applications. ACM Transactions on Intelligent Systems and Technology (TIST), 10(2), 1-19.
Yoon, T., Shin, S., Hwang, S. J., & Yang, E. (2021). Federated continual learning with weighted inter-client transfer. International Conference on Machine Learning, 12073-12086.
Zhao, Y., Li, M., Lai, L., Suda, N., Civin, D., & Chandra, V. (2018). Federated learning with non-IID data. arXiv preprint arXiv:1806.00582.