Federated learning is a machine learning approach that enables multiple devices or servers to collaboratively train a model without sharing raw data. Instead of centralizing data in one location, each participant (e.g., a smartphone, IoT device, or hospital server) trains a local model using its own data. The central server coordinates the process by distributing an initial model, collecting updates from participants, and aggregating them into an improved global model. For example, a smartphone keyboard app might use federated learning to improve word predictions: each device trains on local typing data, sends only model updates (not actual text), and the server combines these updates to refine the shared model.
The process operates in rounds. First, the server selects a subset of devices and sends them the current global model. Each device trains the model locally using its data, computes updates (e.g., gradient adjustments in neural networks), and sends these updates back to the server. The server then aggregates the updates—often by averaging them—to create a new global model. Challenges include handling uneven data distribution (e.g., one device might have mostly images of cats while another has dogs) and device availability (some devices might be offline during training). To address privacy concerns, techniques like secure aggregation (encrypting updates before they leave the device) or differential privacy (adding noise to updates) can be applied. For instance, a healthcare project might use secure aggregation to combine model updates from hospitals without exposing patient-specific data.
Developers implementing federated learning need to consider communication efficiency, model compatibility, and robustness. Frameworks like TensorFlow Federated or PyTorch with Flower provide tools to manage device selection, update aggregation, and encryption. A practical example is training a fraud detection model across banks: each bank trains on its transaction data, and the global model improves without exposing sensitive financial details. Key trade-offs include balancing update frequency (more rounds improve accuracy but increase communication costs) and handling device heterogeneity (varied hardware capabilities or data sizes). By focusing on efficient update compression (e.g., reducing model parameter size) and fault tolerance (handling dropped devices mid-training), developers can build systems that preserve privacy while maintaining model performance.