Federated Graph Learning

The core challenge of FGL is handling structural missing data. Unlike standard federated learning where data points are IID, FGL clients hold subgraphs with missing cross-client edges. Algorithms must account for this topological isolation—where a critical edge connecting a drug node in Hospital A to a protein node in Hospital B is invisible to both during local training. Common solutions include FedSage+, which generates missing neighbor embeddings, and FedGCN, which uses a global adjacency matrix approximation.

FGL requires aligning node embeddings learned from disparate local subgraphs into a unified global representation space without sharing raw adjacency data. Techniques include:

• Federated Node Classification: Each client trains a local GNN on its ego-network, and a central server aggregates weight matrices or gradients.
• Federated Graph Matching: Uses optimal transport to align node embeddings from different clients when node IDs are not shared (common in vertical FGL scenarios).
• Contrastive FGL: Clients maximize mutual information between local node representations and a global summary vector to enforce semantic consistency.

In drug discovery, pharmaceutical companies can collaboratively train GNNs on proprietary molecular interaction graphs without exposing chemical libraries. A typical architecture uses a Message Passing Neural Network (MPNN) locally at each institution to learn atom-level embeddings, while a federated aggregator combines updates to predict binding affinity or toxicity. This is critical for identifying novel drug-target interactions across distributed biobanks where patient-to-variant graphs are siloed by hospital.

Enterprise knowledge graphs are often fragmented across departments or subsidiaries. FGL enables training Relational Graph Convolutional Networks (R-GCNs) on these distributed triple stores. The key technical hurdle is entity resolution across silos—determining that 'Entity A' in Client 1's graph is the same real-world object as 'Entity B' in Client 2's graph without sharing raw entity attributes. Federated link prediction models then learn to infer missing cross-silo relationships.

Standard GNN training requires neighborhood sampling (e.g., GraphSAGE), which in a federated context risks leaking edge information through query patterns. FGL employs differentially private graph sampling where noise is injected into the aggregation of neighbor features. Advanced protocols use secure multi-party computation (SMPC) to compute graph convolutions across clients holding different parts of a node's neighborhood, ensuring no single party sees the complete ego-network.

A unique capability of FGL is predicting edges that span across client boundaries. For example, in a federated patient similarity network, Hospital A and Hospital B can jointly train a model to identify that a patient in A's cohort is clinically similar to a patient in B's cohort—enabling federated cohort discovery—without either hospital seeing the other's patient vectors. This is achieved through federated matrix factorization on the adjacency matrix or by exchanging encrypted node embedding similarities.

The foundational deep learning architecture that operates directly on graph-structured data. GNNs learn node representations by iteratively aggregating feature information from local neighborhoods through message passing. Key variants include Graph Convolutional Networks (GCNs) for spectral convolution, GraphSAGE for inductive learning on large graphs, and Graph Attention Networks (GATs) that weight neighbor importance. In federated settings, each client typically trains a local GNN on its private subgraph before sharing updates.

The process of dividing a large global graph into smaller subgraphs distributed across federated clients. Effective partitioning strategies are critical for model convergence. Common approaches include:

• METIS: A multi-level graph partitioning algorithm that minimizes edge cuts
• Random node assignment: Simple but may destroy community structure
• Community-preserving splits: Maintains local clustering coefficients Poor partitioning leads to missing cross-subgraph edges, which introduces structural bias and degrades the global model's ability to learn long-range dependencies.

A fundamental challenge unique to Federated Graph Learning where nodes near subgraph boundaries lose connections to neighbors residing on other clients. This structural information gap causes local GNNs to compute incomplete neighborhood aggregations. Mitigation strategies include:

• Neighbor embedding sharing: Clients exchange anonymized embeddings of boundary nodes
• Graph augmentation: Generating synthetic inter-subgraph edges using generative models
• Overlap partitioning: Assigning boundary nodes to multiple clients to preserve local context

An adaptation of the GraphSAGE inductive framework for decentralized settings. Unlike transductive GCNs that require full graph structure at training time, GraphSAGE learns aggregator functions that generalize to unseen nodes. In federated deployment, each client trains local aggregator functions on its subgraph, and a central server averages these parameters. This approach is particularly effective for dynamic graphs where new nodes join after initial training, such as new patients added to a hospital network or new molecules in a drug discovery pipeline.

A deployment topology where a small number of institutional clients each hold large, domain-specific subgraphs. Common in healthcare knowledge graphs where hospitals maintain patient-disease-drug networks, or in financial fraud detection where banks hold transaction graphs. Characteristics include:

• Reliable clients: Institutions participate in every training round
• High compute: Each client has substantial GPU resources for local GNN training
• Entity alignment: Requires privacy-preserving record linkage to connect overlapping entities across institutional subgraphs without exposing identities

A federated extension of GATs where attention coefficients are learned locally and aggregated globally. The attention mechanism dynamically weights the importance of neighboring nodes during message passing. In federated settings, this presents unique challenges:

• Attention score alignment: Local attention distributions may diverge across clients with heterogeneous subgraph densities
• Privacy leakage risk: Raw attention weights can reveal structural information about private subgraphs
• Federated attention normalization: Requires cross-client calibration to ensure consistent feature scaling