Federated Learning

Federated learning is a machine learning technique where a model is trained across multiple decentralized devices or servers holding local data, without exchanging the raw data itself. Instead, each device computes an update to the model (e.g., gradient updates) using its local data and sends only that update to a central server, which aggregates the updates to improve the global model. This preserves data privacy because the raw data never leaves the device. Operators encounter federated learning when training models on sensitive data (e.g., medical records, personal messages) that cannot be centralized. It is not a local-AI inference technique but a training paradigm; local AI rigs might participate as clients in a federated training round.

Federated learning was popularized by Google for training keyboard prediction models on Android phones without uploading users' typing data. The standard algorithm is Federated Averaging (FedAvg): each client performs several local SGD steps on its private data, then sends the updated model weights (or gradients) to the server. The server averages the weights from a subset of clients and updates the global model. Key challenges include communication efficiency (compressing updates), statistical heterogeneity (non-IID data across clients), and system heterogeneity (different hardware capabilities). Variants like FedProx and SCAFFOLD address these issues. For local AI operators, federated learning is relevant if they want to collaboratively train a model with others without sharing raw data—for example, a group of researchers each with private datasets training a shared model. However, it requires a central coordinating server and network communication, so it is not a typical workflow for a single local rig.

A group of hospitals wants to train a diagnostic model on chest X-rays without sharing patient data. Each hospital runs a local training script (e.g., using PyTorch) on its own GPU (e.g., RTX 4090). After each round, they send the model weights (not the images) to a central server. The server averages the weights and distributes the updated model back. Each hospital's local GPU handles training on its own data, but the process requires network coordination and a server—not a single-rig workflow.

In practice, operators might use frameworks like Flower or PySyft to set up federated learning. A typical workflow: install Flower, define a client script that loads a model (e.g., a ResNet-18) and trains on local data. Run flwr run client on each machine. The server runs flwr run server. The client sends weight updates after each round. Operators monitor training metrics via the server logs. This is more common in research or enterprise settings than in local AI hobbyist use.