Lumos: Heterogeneity-aware Federated Graph Learning over Decentralized Devices

TL;DR

Lumos introduces a federated GNN framework that preserves privacy and handles node-level heterogeneity, improving accuracy and efficiency in decentralized device networks.

Contribution

The paper presents the first federated GNN framework for node-level federated graphs, incorporating a tree constructor and MCMC-based workload balancing.

Findings

Lumos achieves higher accuracy than baseline methods.

It significantly reduces communication costs.

Training time is greatly decreased.

Abstract

Graph neural networks (GNN) have been widely deployed in real-world networked applications and systems due to their capability to handle graph-structured data. However, the growing awareness of data privacy severely challenges the traditional centralized model training paradigm, where a server holds all the graph information. Federated learning is an emerging collaborative computing paradigm that allows model training without data centralization. Existing federated GNN studies mainly focus on systems where clients hold distinctive graphs or sub-graphs. The practical node-level federated situation, where each client is only aware of its direct neighbors, has yet to be studied. In this paper, we propose the first federated GNN framework called Lumos that supports supervised and unsupervised learning with feature and degree protection on node-level federated graphs. We first design a tree constructor to improve the representation capability given the limited structural information. We further present a Monte Carlo Markov Chain-based algorithm to mitigate the workload imbalance caused by degree heterogeneity with theoretically-guaranteed performance. Based on the constructed tree for each client, a decentralized tree-based GNN trainer is proposed to support versatile training. Extensive experiments demonstrate that Lumos outperforms the baseline with significantly higher accuracy and greatly reduced communication cost and training time.

Equations

$$\text{ENC}:V\to {\mathbb{R}}^d.$$

$${\mathbf{h}}_{\mathbf{v}}^{\mathbf{i}}={\text{AGG}}_i({\mathbf{h}}_{\mathbf{v}}^{\mathbf{i}-1},\{{\mathbf{h}}_{\mathbf{u}}^{\mathbf{i}-1}|u\in \mathcal{N}(v)\}),$$

$$\text{DEC}({\mathbf{h}}_{\mathbf{v}})=\text{READ}({\mathbf{h}}_{\mathbf{v}}),$$

$$\text{DEC}({\mathbf{h}}_{\mathbf{u}},{\mathbf{h}}_{\mathbf{v}})=\text{READ}({\mathbf{h}}_{\mathbf{u}}\cdot {\mathbf{h}}_{\mathbf{v}}).$$

$$\underset{w_{\text{ENC}}}{\min }\sum _{v\in V}\mathcal{L}(\text{DEC}({\mathbf{h}}_{\mathbf{v}}),y_v),$$

$$\underset{w_{\text{ENC}}}{\min }\sum _{u,v\in V}\mathcal{L}(\text{DEC}({\mathbf{h}}_{\mathbf{u}},{\mathbf{h}}_{\mathbf{v}}),y_{(u,v)})$$

$$\underset{w_{ENC}}{\min }\sum _{v\in V}\sum _{u\in \mathcal{N}(v)}\mathcal{L}(\text{DEC}({\mathbf{h}}_{\mathbf{u}}),y_u)$$

$$\text{Pr}\left[\mathcal{R}(\text{x})=\text{y}\right]\le e^{ϵ}\text{Pr}\left[\mathcal{R}(\text{x’})=\text{y}\right]$$

$$\text{For any edge }e=(u,v)\in E,$$

$$x_e=\{\begin{array}{rlr}& 1,& \text{device u includes neighboring vertex v in its tree}\\ & 0,& \text{otherwise}\end{array}$$

$$\underset{x}{\min }f(X)=\underset{x}{\min }\underset{u\in V}{\max }\sum _{(u,v)\in E}{x}_{(u,v)}$$

$$s.t.$$

$$x_{(u,v)},x_{(v,u)}\in \{0,1\},\forall (u,v)\in E$$

$$CC{M}_{ij}=\{\begin{array}{rlr}& 1,& \text{city i has color cj}\\ & 0,& \text{otherwise}\end{array}$$

$$x_{uvk}=\{\begin{array}{rlr}& 1,& \text{Salesman k travels from city u to city v}\\ & 0,& \text{otherwise}\end{array}$$

$$w_{ij}=\{\begin{array}{rlr}& 1,& M^{-1}(i)\cap M^{-1}(j)\ne \varnothing \\ & |V|,& M^{-1}(i)\cap M^{-1}(j)=\varnothing \end{array}$$

$$CC{M}_{ij}=\{\begin{array}{rlr}& 1,& j\in M^{-1}(i)\\ & 0,& j\notin M^{-1}(i)\end{array}$$

$$x_{(u,v)}=\{\begin{array}{rlr}& 0,& \text{round}(\ln \text{deg}(u))\ge \text{round}(\ln \text{deg}(v))\\ & 1,& \text{otherwise}\end{array}$$

$$N_u=N_u\backslash \{v\},N_v=N_v\cup \{u\}.$$

$$\forall v_i\in \{v_1,v_2,\cdots ,v_k\},N_u=N_u\backslash \{v_i\},N_{v_i}=N_{v_i}\cup \{u\}$$

$$Pr[X_{t+1}=X_t^{\prime }|X_t]=\min (1,e^{f(X_t)-f(X_t^{\prime })})$$

$$Pr[X_{t+1}=X_t|X_t]=1-\min (1,e^{f(X_t)-f(X_t^{\prime })}),$$

$$Pr\left[f(X)\le f(X_{opt})-c|E|\ln 2\right]\le e^{-|E|\ln 2}$$

$$Pr\left[f(X)\le m\right]\le \frac{Pr\left[f(X)\le m\right]}{Pr\left[f(X)=f(X_{opt})\right]}$$

$$Pr\left[f(X)\le m\right]$$

$$\le \frac{N\frac{e^m}{{\sum }_X{e}^{f(X)}}}{\frac{e^{f(X_{opt})}}{{\sum }_X{e}^{f(X)}}}\le N{e}^{m-f(X_{opt})}$$

$$Pr\left[f(X)\le f(X_{opt})-(\ln 2)c|E|-t\right]$$

$$\le$$

$$Pr\left[f(X)\le f(X_{opt})-c^{\prime }\ln 2|E|\right]\le$$

$${\mathbf{h}}_{\mathbf{u}}^0=\{\begin{array}{rlr}& {\mathbf{x}}_{\mathbf{u}},& \text{node has features}\\ & 0,& \text{otherwise}\end{array}$$

$${\mathbf{h}}_{\mu }^0=\{\begin{array}{rlr}& {\mathbf{x}}_{\mathbf{u}},& \text{node }\mu \text{ is a leaf related to vertex u∈V}\\ & 0,& \text{otherwise.}\end{array}$$

$$Pr(x_{u,i}^{\prime }=1)$$

$$Pr(x_{u,i}^{\prime }=0)$$

$$x_{u,i}^{\prime \prime }=\{\begin{array}{rlrl}& \frac{b-a}{2}\frac{e^{\frac{ϵ\text{wl}(u)}{d}}+1}{e^{\frac{ϵ\text{wl}(u)}{d}}-1}+\frac{a+b}{2},& x_{u,i}^{\prime }& =1\\ & \frac{a-b}{2}\frac{e^{\frac{ϵ\text{wl}(u)}{d}}+1}{e^{\frac{ϵ\text{wl}(u)}{d}}-1}+\frac{a+b}{2},& x_{u,i}^{\prime }& =0\\ & \frac{a+b}{2},& x_{u,i}^{\prime }& =0.5\end{array}$$

Full text

I Introduction

Graph-structured data are common in the real world. They can effectively represent complex relations in social networks, communication networks, and transportation networks. Unlike typical data with simple structures, the complex graph topology underlying the graph data sophisticates the corresponding prediction tasks. Graph representation learning addresses the problem by reducing complex graphs into low-dimensional vectors. Graph neural networks (GNN) have drawn significant attentions in recent years due to their powerful representativeness. Its outstanding performance relies upon message passing among neighboring vertices and the powerful expressiveness of the neural network. GNN has been widely used in networked systems and applications, like gross merchandise value forecast in e-commerce graph[1], item recommendation in knowledge graphs[2] and docked bike prediction in spatial-temporal bike-sharing networks[3].

The growing awareness of data privacy and the formal establishment of regulations such as GDPR[4] and CCPA[5] motivate a new paradigm called Federated Learning (FL)[6]. Instead of training neural network models on a server that stores all the data, FL trains models on local devices without uploading private data to the server. The server only receives the individually trained models and aggregates them to derive a global one. Along with efforts to protect typical sequence-like or grid-like data, e.g., texts and images, topological information such as node degree in graph data also calls for stricter privacy protection as they usually embed essential personal information.

Federated GNN aims to collaboratively train the GNN with privacy preservation of graph data. Existing federated GNN studies can be categorized into the following three types, depending on how much graph information each device has: (1) Graph-level separation [7, 8] allows each client to have a complete graph with common nodes but different node features and edges. It usually models the collaboration among different organizations with different graph data. (2) Subgraph-level separation [9, 10, 11] splits a graph into small subgraphs and each device stores one subgraph. It is applicable in recommendation user-item networks. (3) Node-level separation [12, 13] only allows each device to hold its own ego-network, namely, each device is only aware of the connection information between itself and its direct neighbors. It is the most natural form in sensor networks, social networks, and the emerging decentralized applications [14]. Different levels of separation demand specific designs of federated systems. The limited availability of the structure information in a node-separated graph greatly hinders the capacity of the graph learning. Up till now, although existing federated GNN models are capable of learning graph representations while protecting local feature data in node-separated settings, they all leave the critical local node degree exposed[12, 13].

This paper aims to fill the gap to fully protect local feature and node degree in the node-level federated setting. The challenges come from three perspectives. First, learning. Inaccessibility of the complete graph information significantly limits the structural awareness of each device. Obtaining representative node embeddings in such a strict environment calls for a new federated GNN design. Second, privacy. Node features, as well as node degree, all require privacy protection. How to protect these information from other clients and the central server, preferably being theoretically guaranteed, is non-trivial. Last but not least, degree heterogeneity. Skewed degree distribution in real-world graphs lead to heterogeneous sizes of ego networks across different devices. Directly computing on these ego networks makes certain devices stragglers, and thus prolongs the whole training process. How to mitigate the effect of stragglers caused by the degree heterogeneity should be addressed.

This paper introduces Lumos, a federated GNN framework over a decentralized node-separated graph with both features and degrees protected. Lumos comprises a heterogeneity-aware tree constructor and a tree-based GNN trainer. The first module, a heterogeneity-aware tree constructor, is judiciously designed to construct a tree-structured graph with virtual nodes from the original ego network stored in each device. The vertices111We use vertex and node interchangeably in this paper. involved in the tree are wisely selected by a Monte Carlo Markov Chain (MCMC)-based algorithm to balance the computing workload across different devices. Each device then considers the constructed tree as a graph to represent GNN layers. The tree-based GNN trainer is further proposed to train those trees to learn the representation of vertices in the global graph with privacy preserved. A fully decentralized inter-device communication scheme facilitates the aggregation of the embeddings of the same nodes in different devices. Devices then use the aggregated embeddings to compute the loss and improve the neural network.

In summary, our contributions are as follows:

• •

We propose the first federated GNN framework in the node-separated setting to efficiently support supervised and unsupervised GNN training with degree protected.

• •

A novel tree structure is designed to improve graph representation for each device with only local information. A tree-based GNN trainer is further proposed with the privacy of feature and degree protected.

• •

We propose a MCMC-based iterative algorithm to mitigate the workload imbalance problem caused by the newly identified degree heterogeneity. The performance of our algorithm is theoretically guaranteed.

• •

Extensive experiments demonstrate that Lumos significantly outperforms the federated baseline by a 39.48% accuracy increase, reducing 35.16% of inter-devices communication rounds and 17.74% of training time.

The structure of this paper proceeds as follows: We first present a basic introduction to deep graph learning in Section II. Then we review the related works in Section III. In Section IV, we provide an overview of the whole system. Section V introduces the first module of Lumos, heterogeneity-aware tree constructor; Section VI introduces the other part, tree-based graph neural network training in details. Results based on extensive experiments are presented in Section VIII, followed by the conclusion in Section IX.

II Preliminaries on Graph Neural Networks

In this section, we present a preliminary introduction to the centralized deep graph learning algorithms. GNN has been widely studied in recent years due to its great power in processing graph-structured data [15, 16, 17]. It embeds nodes through the aggregation of neighboring embeddings and self-embeddings. The resulting embeddings serve as the representative features to help a wide range of high-level downstream tasks in networked systems, like e-commerce [1], recommendation system[2], transportation networks[3], and user behavior networks[18], to name a few.

Graph learning assigns low-dimensional vectors that extract the local features and structural topology to all the vertices. Given a graph $G=(V,E)$ with $\mathbf{X}=(\mathbf{x_{v}})_{v\in V}$ where $\mathbf{x_{v}}\in\mathbb{R}^{D}$ refers to the vertex feature of $v$. Graph learning is defined with an encoder and a decoder. The encoder is a mapping from vertices to low-dimensional vectors,

[TABLE]

In GNN, the encoder is a sequence of message passing layers where each layer is defined as

[TABLE]

where $\mathbf{h_{v}^{i}}$ is the embedding output of the $i$th layer, AGG refers to the aggregation function, and $\mathcal{N}(v)$ is the neighbor set for a specific $v$. The initial embeddings $\mathbf{h_{v}^{0}}$ are usually set as the local features $\mathbf{x_{v}}$. Each layer aggregates the embeddings of one vertex and its neighbors so that the generated vector extracts not only local features but also features from neighbors. The decoder, denoted as DEC, is a function that reconstructs specific graph data from embeddings. For vertex-related tasks, e.g. node classification, the decoder reconstructs the vertex data from the embeddings.

[TABLE]

where READ refers to single or multi-layer perceptrons. For edge-related tasks, e.g. link prediction, the decoder is usually pairwise, involving edge-related statistics,

[TABLE]

The graph learning problem can be formulated in vertex-related tasks as

[TABLE]

where $w_{\text{ENC}}$ are all the parameters in the encoder function, and $\mathcal{L}$ is a loss function to measure the error of the models to achieve the construction goal. Similarly, in edge-related tasks, the formulation is

[TABLE]

where $y$ can be manual labels or a binary number representing the existence of graph elements.

III Related Work

In this section we review the current works from three aspects: federated learning, graph neural networks, and federated graph learning.

III-A Federated Learning

The Federated learning paradigm has advanced in the last few years since it successfully tackles the data privacy issue in machine learning algorithms[6]. Through the collaboration of neural network training, federated learning trains models without the centralization of raw datasets. However, federated learning suffers performance degradation due to various types of heterogeneity, like data distribution heterogeneity[19] and resource heterogeneity[20]. To address these types of heterogeneity, a federated learning system usually modifies the default model aggregation protocol or client sampling strategy through heuristic algorithms, reinforcement learning, and clustering algorithms. In [21], researchers theoretically prove that learning rate decay can resolve the non-iidness of data. In [22], researchers propose an experience-driven algorithm based on deep reinforcement learning to solve a mobile computational resource heterogeneity problem in federated learning. In [23], a clustering-based FL framework is proposed to tackle the network communication heterogeneity problem. However, the characteristics of graph data lead to a new type of heterogeneity, like the skewed distribution of node degrees and different levels of graph sparsity, which is difficult to handle using previous approaches.

III-B Graph Neural Networks

Graph neural networks have emerged as an efficient tool for graph learning. Various neural architectures are introduced to generate node embeddings and fulfill graph-related tasks, such as GCN[15], GAT[16], and GraphSage[24]. However, these GNN architectures suffer from limited expressiveness due to the message-passing framework in vanilla GNNs, validated by the incapability to distinguish non-isomorphic graphs[25] and difficulty in approximating combinatorial problems[26].

To overcome this shortage, scientists have modified the message-passing framework so that features can be extracted and aggregated in a new manner. One way is to reconstruct the graph structure by adding virtual nodes. In [27], researchers append virtual nodes to the graph to form junction trees to improve the expressive power of GNN. In [28], a new GNN architecture called Neural Tree operates message passing on H-tree constructed from the original graph by linking virtual nodes to actual nodes. Similar to these studies, in our problem, the limited expressive power of vanilla GNN architectures makes embedding nodes in small ego networks inaccurate. Therefore, we also modify the ego network to improve representativeness.

III-C Federated Graph Learning

Federated graph learning collaboratively trains the GNN in a privacy-preserving way. True structural information and raw feature information are not allowed to share with other devices and the server. Separation of graph statistics across different devices greatly impedes the model training and affects the GNN’s representativeness. Various frameworks have been proposed under different levels of separation to tackle the problem.

In graph-level separation, each client owns one or more complete graphs with common vertices but different features or connection information. GCFL in [7] clusters local graphs using gradients of GNN networks to improve overall performance. In [8], FedGL takes advantage of prediction results and node embeddings to facilitate global graph self-supervision to address varying node label distribution, different graph sparsity, and non-iid node feature problems.

For subgraph-level separation, each device owns a subgraph of the global graph. FedSage+ in [9] utilizes a missing neighbor generator on top of the system to deal with missing links across subgraphs. In [10], FedGraph uses a novel cross-client convolution operation to address feature data sharing among devices and an intelligent graph sampling algorithm based on deep reinforcement learning to balance training speed and accuracy. Researchers in [11] propose a practical federated graph learning system that deals with the trade-off among GCN convergence error, wall-clock runtime, and neighbor sampling interval.

For node-level separation, each client only owns an ego network from itself. Namely, each client is only aware of its direct neighbors and the edges to its neighbors. SGNN in [12] uses one-hot encoding to encrypt features and introduces a new node distance calculation method based on an ordered degree list to process structural information. LPGNN in [13] encrypts local features using a modified one-bit encoder and a robust training framework to increase inference accuracy in the presence of noisy labels. These works focus on protecting local features, but leaves the edge information exposed. A recent work, FedWalk in [29], modifies Deepwalk method in centralized settings to protect edge information. However, the system is limited in representativeness as GNN outperforms DeepWalk. We focus on designing a federated GNN system while protecting both feature and degree. We also reveal a new workload imbalance problem caused by degree heterogeneity in node-separated setting, and propose a theoretically-proved approximation algorithm to solve it.

IV Lumos overview

In this section, we first describe the problem to solve. We then provide a general overview of Lumos framework.

IV-A Problem Description

For generality, we assume a networked system with $|V|$ end devices and a server. We can index the vertices with positive integers $1,2,\cdots,|V|$. Each device is represented by a vertex $v$ in a graph and devices that have a relationship to each other form an edge. Each device further contains local features that are generated by itself. We can represent the underlying system as a graph $G=(V,E)$, where $V$ denotes the total vertex set and $E$ denotes the total edge set. Each device holds its ego network denoted as $\mathcal{E}(v)$ containing all the neighboring vertices222We use device $v$ to represent the device storing $\mathcal{E}(v)$ in the following.. $\mathcal{E}(v)$ only contains feature $\mathbf{x_{v}}$ and label $y_{v}$ without any node information related to other vertices. For example, for a decentralized social networking application, each device relates to a social network account. The social relationship in such an application can be represented as edges. The generated texts, images of each client is the local feature.

The system needs to calculate the node embedding for each device with both the local feature and degree protected from other devices and the server. We can formulate the goal of the system as

[TABLE]

Inter-device communications are allowed and necessary to accomplish the goal of the system. However, all the devices follow the semi-honest adversary model. In other words, they may infer the private information of others from received data without violating the system protocol. More specifically, the local features should all be preserved with $\epsilon-$ local differential privacy[30] defined formally in Definition 1.

Definition 1**.**

Let $\epsilon\in\mathbb{R}^{+}$ and $\mathcal{R}$ be a randomized mechanism. The mechanism $\mathcal{R}$ is said to preserve $\epsilon-$ local differential privacy on feature x if for any feature pair $(\textbf{x},\textbf{x'})$,

[TABLE]

The node degree follows a zero-knowledge protocol[31], a method by which one party (the prover) can prove to another party (the verifier) that something is true without revealing any information apart from the fact that this specific statement is true. The zero-knowledge protocol in our federated system concerning node degree is defined in Definition 2.

Definition 2**.**

Let $u$ and $v$ be two devices that need to compare their node degrees to distribute workloads. A protocol is said to protect the privacy of node degrees under zero-knowledge protocol if one device only knows the comparison result but does not know any additional information about the other device’s node degree.

In our scenario, we use zero-knowledge protocol to protect node degree information when balancing device workload based on the comparison of node degrees. Specifically, we design a zero-knowledge protocol to compare the degrees of the two devices. The result of the comparison is whether the node degree of one device is bigger or smaller than the other device, which is known to both devices. Other than this result, each device will not know any additional information about the other device’s node degree.

After the formal description of our learning goal and the privacy requirements, we next present the definition of degree heterogeneity in the node-level federated graph learning system and its implications upon federated GNN model training.

Definition 3** (Degree Heterogeneity).**

Degree heterogeneity refers to skewed degree distribution in real-world graphs which leads to heterogeneous sizes of ego networks across different devices.

Given that the ego networks are of varying sizes, the workload distribution across different devices is skewed in the node-level federated graph learning system. Since the devices in practice usually have limited computing power and storage resources, directly computing on these ego networks makes some devices run slower than others, also known as stragglers in distributed systems, and thus prolongs the whole training process. Furthermore, the imbalanced workload caused by degree heterogeneity also introduces high computation costs on certain edge devices. Hence, the system should be wisely designed by reducing the size of large local graphs to avoid excessive communication and computation costs.

IV-B Lumos*: Solution Overview*

As shown in Fig.1, Lumos comprises two modules, a heterogeneity-aware tree constructor and a tree-based GNN trainer. Except the MCMC iteration where server-device communication is required, the rest parts in Lumos are fully decentralized without server coordination. Lumos is a synchronize federated framework that operates in rounds and has to receive all the required updates to start the next round.

The original ego network is not expressive enough to train GNN layers as most ego networks contain a minimal number of vertices[32]. The tree-constructor converts $\mathcal{E}(v)$ in each device into a particular tree, denoted as $\mathcal{T}(v)$, with leaves corresponding to the vertices in the subgraph and virtual internal nodes. However, the degree heterogeneity introduced in Definition 3 incurs a heavy workload imbalance problem in the following GNN trainer, slowing the overall completion time for each training epoch. Since each edge exists in two subgraphs, one subgraph can remove that edge to reduce the number of leaves in the tree. The tree constructor uses a greedy initialization and an MCMC iteration to trim trees so that the numbers of leaves are balanced across devices. During the tree trimming process, the workload values are encrypted to follow the zero-knowledge protocol for comparison.

A tree-based GNN trainer trains a particular GNN network with the constructed trees. An embedding initialization encrypts features with local differential privacy because of privacy concerns. Then the device transmits the features to their neighboring devices. Each device trains GNN layers upon its tree using these encrypted features as initialized embeddings. The layers generate representations for all the leaves associated with vertices in the graph. After that, a POOL layer gathers all the embeddings of leaves in multiple trees corresponding to the same vertex in the global graph to generate the vertex embeddings through inter-device communications.

The system uses multiple approaches to meet the requirement of privacy. In the tree-constructor, the exchange of workload statistics implies the degrees of the clients. Hence, the tree-constructor deploys an integer comparison encryption protocol so that the information is exchanged under security. As mentioned, embedding encryption prevents node feature leakage in the graph neural network trainer. Moreover, the system guarantees that labels of nodes are used locally without joining the inter-device communication.

V Heterogeneity-Aware Tree Constructor

In this section, we introduce the first part of Lumos, heterogeneity-aware tree constructor. We first present the intuitive idea of tree construction and identify the potential workload imbalance issue due to degree heterogeneity in the system. Then we formulate the workload balance problem. Last, we propose a tree-trimming solution to the problem.

V-A Initial Tree Construction

The idea of the tree construction is to insert some virtual nodes into the ego network, forming a particular tree to strengthen its expressiveness. Thus, for device $v$, its tree $\mathcal{T}(v)$ is combined with real vertices in the ego network and virtual nodes. The leaves in $\mathcal{T}(v)$ correspond to the real vertices in $\mathcal{E}(v)$ while the internal nodes are virtual without a direct relationship to the real vertices. The tree is constructed from the bottom to the top. We first create leaf pairs. A leaf pair $(v,u)$ is consisted of the vertex $v$ itself and one of its selected neighbor $u\in\mathcal{N}(v)$. Here, node $v$ is replicated $|\mathcal{N}(v)|$ times so that the only non-noised feature in this ego-graph333In subsection VI-A, it will be introduced why and how other features are noised due to privacy restriction. is utilized more in later training. Then we add a common parent node to the two leaves in each pair to join them. Last, we use a root node to make all the parent nodes children of the root node in the tree. This tree architecture includes virtual nodes representing subgraphs in the original graph. The virtual root node represents the whole ego network, and each virtual parent node of leaves refers to a two-vertex subgraph, including its two child vertices and the edge between them. These virtual nodes allow the tree to express more structural information about the original ego network. A general version of this tree architecture can learn any graph compatible function and have great expressive power [28].

We further use the ego network generated by vertex $1$ in Fig.2 as an example to illustrate this tree construction process. First we form 4 leaf pairs $(1,2),(1,3),(1,4),(1,5)$ by joining vertex $1$ and its neighbors together. Then we add four parent nodes $P_{1}$, $P_{2}$, $P_{3}$, and $P_{4}$ to these leaf pairs accordingly. Lastly, we use a root node $R$ to connect these four parent nodes to build a tree. Then, we use the same example to explain why Lumos constructs a tree in this way. Since vertex 1 and 2 are symmetric in the subgraph formed with vertex 1, 2, and edge (1,2) in the original ego network, node $P_{1}$, as a parent of leaves vertex 1 and 2, represents the corresponding subgraph structure accurately. Similarly, nodes $P_{2}$, $P_{3}$, and $P_{4}$ exactly represent their related two-vertex subgraphs. As the root node $R$ is the parent of these four virtual nodes representing all the symmetric two-vertex subgraphs in the ego network, $R$ precisely represents the whole ego network structure.

Although the constructed tree is expressive, it suffers from workload imbalance problem due to degree heterogeneity defined in Definition 3. Some devices become stragglers and slow down the overall learning speed in the distributed system. Worse, it may make one edge device crash down, given that it needs to learn a tree-structured graph of more than thousands of nodes. These potential problems drive us to design a heterogeneity-aware tree constructor.

V-B Workload Balancing Problem Formulation

We can use a 0-1 integer programming model to formulate the workload balancing problem. The workload of each device depends on the number of leaves of the tree. The decision variable is a matrix $X\in[0,1]^{|E|}$.

[TABLE]

Since the number of leaves in the tree is equal to $2\sum_{e\in E}x_{e}$ for each device due to the leaf pairs introduced above, we define $f(x)$ as the maximum workload in the graph, namely, $f(x)=\max_{u\in V}\sum_{(u,v)\in E}x_{(u,v)}$. Hence, the workload balancing problem is modeled as

[TABLE]

The objective function is a min-max function, forbidding the existence of a device that undertakes excessive workload in the whole system. The constraint equation guarantees that every edge is represented in at least one tree. However, this problem is non-trivial to solve. Specifically, we present Theorem 1 to show its hardness.

Theorem 1**.**

The workload balancing problem defined in (10) is NP-hard.

Proof.

We formulate our problem as a min-max Colored Traveling Salesman Problem (CTSP). In CTSP, there are $m$ salesman and $n$ cities. A digraph $\mathcal{G}=(\mathcal{V},\mathcal{E})$444We use $G=(V,E)$ to denote the graph in federated GNN and $\mathcal{G}=(\mathcal{V},\mathcal{E})$ to denote the graph in CTSP to distinguish these two graphs. where $\mathcal{V}=\{1,2,\cdots,n\}$ indicates the traveling route between cities. For edge $(u,v)\in\mathcal{E}$, it has a non-negative weight $w_{u,v}$ quantifying the traveling cost from city $u$ to city $v$. Each salesman is assigned a distinguished color. Denote the color set to be $C=\{c_{1},c_{2},c_{3},\cdots,c_{m}\}$. An indicator matrix called City Color Matrix (CCM) with size $n\times m$ allocates cities with one or more colors.

[TABLE]

A salesman can only travel to cities with his corresponding color. Each salesman $k\in\mathbb{Z}_{m}$ starts to travel from a city $s_{k}$ and returns to the city in the end. The decision variable $X\in\mathbb{R}^{n\times n\times m}$ is a tensor.

[TABLE]

The problem aims to assign different traveling routes to salesmen with the least traveling costs.

In our problem, we aim to balance the number of vertices to process in each device. Each device represents a salesman, and each edge is a city to visit. We define a mapping function from the edge to the city as $M:E\rightarrow\mathcal{V}$. The graph $\mathcal{G}$ in our scenario is a complete graph where all the vertices are connected. The weights are

[TABLE]

which heavily punishes assigning a route across an inaccessible city for a salesman. Due to privacy concerns, for an edge $(u,v)\in E$, only devices corresponding to vertices $u$ and $v$ are allowed to process the edge. In this way, we assign every salesman with different colors. The starting point of each salesman is randomly assigned from the set of cities he can visit. CCM is defined as

[TABLE]

In this way, our problem is equivalent to a min-max CTSP problem. It is obvious that the single TSP problem can be reduced to the min-max CTSP problem when $m=1$. Since finding the exact solution to the single TSP problem is proved to be NP-hard[33], our workload balance problem, a min-max CTSP problem, is NP-hard. ∎

V-C A Solution to Workload Balancing Problem: Heterogeneity-aware Tree Trimming

Since the problem is NP-hard, finding the optimal solution on real-world, large-scale datasets is infeasible. Although it is difficult to find the exact solution, we propose a method to approximate the optimal solution. Our method consists of two parts, one is a greedy initialization algorithm to trim branches into a sub-optimal tree, and the other is an iterative algorithm based on Markov chain Monte Carlo (MCMC) sampling. We prove this heterogeneity-aware tree trimming method has bounded loss compared to the optimal solution.

Greedy initialization

It is critical to generate an initial solution with relatively small objective values. Otherwise, it will take tremendous time for the following iterative algorithm to converge, particularly in a large-scale global graph. If two vertices are linked, but their degree difference is vast, the device with the more considerable degree trims the branch with the other device to decrease the workload difference.

The initial solution is defined according to

[TABLE]

Realizing this simple setting is non-trivial in our scenario, requiring a integer comparison to compare two degrees. Since the degree value reveals structural information of the vertex, it needs privacy preservation. We use the 2-party protocol for integer comparison problem in CrypTFlow2[34] due to its efficiency and decentralized setting. Other degree protection mechanisms such as graph anonymization [35] require complete graph structure on the server. This is inaccessible in our federated scenario because it leaks the local graph neighboring information to the server. Taking the logarithm of degrees makes the bits of inter-transmission during secure integer comparison much smaller. It also reduces the unnecessary workload for vertex pairs with a slight degree value difference. The initial solution fills the workload gap between two devices with a significant degree difference. The initialization process can be summarized in Alg.1. Alg.1 has time complexity $O\left(\max_{v}\deg(v)\mathcal{L}\log\mathcal{L}\right)$ where $\mathcal{L}$ is the number of the bits of store each degree value, as within each device, it runs a degree comparison computation for all its neighbours and $O(\mathcal{L}\log\mathcal{L})$ is the complexity of integer comparison[34].

Alg.1 outputs a list of vertex sets whose element $N_{u}$ is the remaining neighbor set for vertex $u$. The step written in Line 4 utilizes the integer comparison protocol. The output of Alg.1 will be updated using an iterative algorithm introduced below.

Iterative Algorithm

The algorithm iteratively searches for solutions with smaller objective values using MCMC sampling. We consider each solution as a state and is transitive to another using a transition approach. The transition performs the following operation. For one edge $(u,v)\in E$, and $v\in N_{u}$

[TABLE]

It trims the branch including one neighbor $v$ from $\mathcal{T}(u)$ and adds a branch including node $u$ into $\mathcal{T}(v)$.

To speed up sampling, we compare the objective values of states before and after $k$ transitions by requesting the devices with the largest workloads given different solutions to compare with each other. Hence, $k$ transitions operate as

[TABLE]

where $k$ is a random number sampling from $1$ to round$(\ln|N_{u}|)$.

The current state $X_{t}$ will jump to the transited one $X_{t}^{\prime}$ with a probability

[TABLE]

applying the Metropolis-Hastings (MH) algorithm [36] which performs state sampling from distributions of all kinds. Eq.18 allows the state to be transited to a less optimal state with a minuscule probability. Occasionally, a less optimal state will lead to an optimal state with smaller transitions.

To compute $f(X_{t})-f(X^{\prime})$, we use the 2-party protocol for number computation in CrypTFlow2[34]. The time complexity is $O\left(T|V|\mathcal{L}\log\mathcal{L}\right)$ where $\mathcal{L}$ is the number of the bits to store per workload integer value. For each iteration, the highest cost occurs during execution of Alg.3, which needs to run no more than $|V|$ times of integer comparison of time complexity $O(\mathcal{L}\log\mathcal{L})$ on each device in parallel.

Steps written in Line 2 and 6 in Alg.2 require finding the device with the maximum workload. Devices cannot share their workload values directly, similar in greedy initialization. Hence we need to deploy the integer comparison protocol used in Alg.1 to develop a system-coordinated module. The algorithm can be divided into two parts. The first part (Line 1-8 in Alg.3) is to find a CVS, which is the abbreviation for candidate vertex set, containing all the devices which hold the largest workloads among their neighbors and themselves. Each device first checks whether it is a candidate vertex by comparing its workload with the workloads of its neighboring devices. If it undertakes the largest workload across its ego network, it sends a message to the server. After the server receives all the candidate vertices, it executes the second part. It requests all the devices in CVS to compare themselves with each other. The device with the largest workload among the candidates is expected and informs the server. If more than one device are found, the server randomly selects one as they have the same maximum workloads. Alg.3 presents the procedure.

Theorem 2**.**

The probability of sampling a solution with $f(X)=f(X_{opt})-c|E|\ln 2$ decreases with exponential in $|E|\ln 2$.

[TABLE]

Proof.

Let $m\in[0,1]$. We have

[TABLE]

Since every state can be obtained through a sequence of transitions from another state, the Markov Chain is connected. Since $Pr\left[f(X)\right]>0$, the Markov chain is ergodic and reversible[37]. The standard MH procedure and the property of the Markov Chain guarantee that the final solution will converge to the stationary distribution. Hence,

[TABLE]

where $N$ is the number of states in the Markov Chain. In our scenario, $N=2^{c|E|}$ where $c$ is a constant. Let $m=f(X_{opt})-\ln(N)=f(X_{opt})-(\ln 2)c|E|-t$ where $t\in\mathbb{R}$. Then,

[TABLE]

Let $t=(\ln 2)|E|$. We have

[TABLE]

where $c^{\prime}=c+1$. This completes the proof. ∎

Theorem 2 theoretically bounds the probability of obtaining a solution far from the optimal using our approach.

VI Tree-based Graph Neural Network Training

In this section, we introduce the second module of Lumos, graph neural network trainer. We describe embedding initialization, message passing and loss computing, all key components in GNN training, in details sequentially. In general, after balancing the computation workloads for each device, each device now has a tree-structured graph of an adequate size, which allows graph neural network training. Every device performs message passing on its tree, including all the leaves and internal nodes. It uses an unbiased encoder to encrypt local features to protect $\epsilon-$ local differential privacy. The system combines all the embeddings of leaves corresponding to the same vertex through inter-device communications to obtain the final vertex embeddings. These embeddings are then used to compute loss values to update model weights.

VI-A LDP Embedding Initialization

In centralized GNN, the initial embedding of vertex $u$ is

[TABLE]

Since for the tree-structured graph, the leaves correspond to the original vertex in the global graph, they are thus featured. The internal nodes are virtual nodes to facilitate training without features. Hence, we define the initial embedding of node $\mu$ in the tree as

[TABLE]

Nevertheless, privacy concerns impede the direct publication of node features. Node features need encryption without losing much utility. We take advantage of the one-bit mechanism [38] to send local features to other devices. Assuming that $\mathbf{x_{u}}\in[a,b]^{d}$, for the $i$th element, the probability to map the element value to $\{0,1\}$ is

[TABLE]

where $\epsilon$ is a hyper-parameter called privacy budget to control privacy protection and $\text{wl}(u)$ is the workload value of degree u, i.e., the number of neighbours remaining in the trimmed tree $\mathcal{T}(u)$. A smaller $\epsilon$ protects more privacy despite more information loss. The mapping probability $Pr(x_{u,i}^{\prime}=1)$ is large when the element value is close to $b$. On the other hand, $Pr(x_{u,i}^{\prime}=0)$ is large when it is close to $a$.

Naively encoding all the feature elements with the 1-bit mechanism successfully transmits all the dimensions of local feature to its neighboring clients to some extent. Yet, every featured element suffers a huge utility loss , making the final embeddings deviate far from the optimal. Hence, the feature encoder only encodes part of them while abandoning the rest. Specifically, the feature encoder distributes the $d$ encoded elements into $\text{wl}(u)$ bins randomly. It sends a partial encoded feature only containing the elements in the $k$th bin to the $k$th neighbor respectively for all $k\in\mathbb{Z}_{\text{wl}(u)}$. Distributing encoded elements ensures that all the feature information are sent to one of its neighbors for further aggregation. The partial feature fills the missing elements with 0.5, implying no deviation towards the maximum or minimum value and transmitting no information. Compared with encoding all the elements, the encoded features protect privacy by sending part of data under the same budget. Moreover, since parts of elements are constant, encoded features have lower variance compared to sending fully encoded features, resulting in a better model.

After the devices compute the encoded features $\mathbf{x_{u}^{\prime}}\in\{0,0.5,1\}^{d}$, they calculate the recovered features $\mathbf{x_{u}^{\prime\prime}}$ from

[TABLE]

It is worth noting that the recovered features are not equal to the original features. They only reveal the tendency of the feature values towards the lower bound $a$ or the upper bound $b$. However, we can prove that such a recovery process do not incur too much utility loss using the following theorem.

Theorem 3**.**

*The recovered features are unbiased.

Proof.

Let $\epsilon^{\prime}=\frac{\epsilon\text{wl}(u)}{d}$. We know that $x_{u,i}^{\prime}$ follows a Bernoulli distribution. In this way,

[TABLE]

We can rewrite Eq.27 into

[TABLE]

Then,

[TABLE]

which completes the proof. ∎

The unbiasedness of the recovered features prevents significant utility loss of the feature encoder. Upon recovering features, each device sends them to neighbouring devices and starts training based on the following message passing design.

VI-B Message Passing

Each device considers its tree as a graph and performs message passing along the tree branches. It updates the node embeddings in its device using $l$ graph neural network layers. A tree-based GNN layer is defined as Eq.2. After an $l$-layer update, each device sends the embedding of leaves corresponding to its neighboring vertices to their own devices.

Upon receiving the updated embeddings of different leaves, the device combines them to generate the final vertex embedding using a pooling function. The pooling function allows the message to pass across multi-hop neighbors as the embeddings before pooling are generated from different trees, revealing neighboring information of different vertices. We use an average pooling function in the experiment.

[TABLE]

VI-C Loss Computing

Device $u$ now obtains its own vertex embedding $\mathbf{h_{u}}$. Then it needs to calculate the loss value to operate backward propagation. GNN performs well in supervised learning and unsupervised learning scenarios. Our system is compatible in both settings.

Supervised learning

Device $u$ is aware of its label $y_{u}\in\mathbb{Z}_{L}$. Locally it can use a linear layer to convert the $d$ dimensional embedding $\mathbf{h_{u}}$ into an $L$ dimensional vector $\mathbf{z_{u}}$.

[TABLE]

It then uses an activation function such as softmax to convert the embedding into a probability vector $\mathbf{p_{u}}\in[0,1]^{L}$. The device can now use the classical cross-entropy loss function to compute the loss.

Unsupervised learning

Unsupervised learning requires to embed nodes without any label data. However, the model needs to update its weights by evaluating how representative its current embeddings are. To this end, Lumos performs a link prediction task to compute the loss values as a compensation for the non-existence of labeling data since device $u$ is aware of its neighboring vertices $\mathcal{N}(u)$. Device $u$ requests all the selected vertices $N_{u}$ to send their embeddings $\{\mathbf{h_{v}}|v\in N_{u}\}$. Then device $u$ negatively samples vertices that are not its neighbors in the global graph and requests their embeddings $\{\mathbf{h_{v^{\prime}}}\}\sim P_{\{\mathbf{h_{v}}|(u,v)\notin E\}}$. The network prefers proximate embeddings for neighboring vertices and distinct for distanced vertices. In this way, we can compute the loss value.

[TABLE]

After computing the loss value of each node in each device, the devices share their loss values with each other and aggregate them to get the final loss value. Then all the devices can operate backward propagation to update the weights in the network. The training process continues until the network model converges.

VII Privacy Analysis

In this section, we present a privacy analysis to show that Lumos meets the privacy requirement restrictively. First, we analyze the privacy protection of features. In Lumos, the only module to transmit local features is the embedding initiator. Theorem 4 states that the encoding before feature exchange is a $\epsilon$-local differential privacy mechanism.

Theorem 4**.**

The embedding initialization protects $\epsilon$-local differential privacy.

Proof.

We deploy a 1-bit encoder and a bijective recovery process to every selected feature bit with the noise parameter $\frac{\epsilon\text{wl}(u)}{d}$. The 1-bit encoder is proved to protect $\epsilon-$ local differential privacy[38]. The composability property of LDP [39] ensures that a series of randomized mechanisms with $\epsilon_{i}$-LDP ensures $\sum_{i}\epsilon_{i}$-DP in total. Therefore, the feature encoder satisfies $\frac{d}{\text{wl}(u)}\cdot\frac{\epsilon\text{wl}(u)}{d}=\epsilon$-DP. The recovery function is bijective, so it doesn’t impact the $\epsilon-$LDP protection of the encoder. Hence, the embedding initialization protects $\epsilon-$local differential privacy. ∎

Next, we analyze the privacy protection of node degrees. In Lumos, degree privacy protection follows zero-knowledge protocol as required.

Theorem 5**.**

*Lumos protects node degree under a zero-knowledge protocol. *

Proof.

Lumos deploys a 2-party encryption protocol in CrypTFlow2[34] to protect the original node degree and make integer comparison computations. The encryption protocol is a hybrid algorithm of multiple oblivious transfer steps[40]. In [41], it is proved that oblivious transfer guarantees a zero-knowledge proof. ∎

VIII Evaluation

In this section, we present the experimental results and analysis of Lumos. We first examine how Lumos performs compared to baseline systems in supervised and unsupervised scenarios. Then we perform sensitivity analysis of privacy parameter $\epsilon$. Last but not least, we conduct ablation study by replacing two key components in Lumos to show their irreplaceability in terms of accuracy and system cost.

VIII-A Dataset

We use two social network graphs with different sizes: Facebook[42] and LastFM[43]. We split the graphs into $|V|$ ego networks so that each device represented by one vertex in the graph holds its corresponding ego network. The ego networks only include the feature and label for the central vertex without any node information related to other vertices.

• •

Facebook page-page graph describes the interaction among different Facebook pages as a representation of online social relationships. Its 22,470 vertices are all Facebook pages, and 170,912 edges represent a mutual “like”. 4,714 vertex features are obtained from the page descriptions. Its label is the category of the pages. There are 4 categories.

• •

LastFM graph is crawled from a music streaming website, LastFM. Its 7,624 vertices are users, and the 55,612 edges represent “following” relationship between them. Its 128 vertex features are users’ preferred musicians. Its label is the nationality of the user. There are 18 classes.

VIII-B Experimental Settings

In the tree constructor, we run 1,000 MCMC iterations for Facebook dataset and 300 for LastFM dataset to balance workloads and construct trees. We utilize GCN [15] and GAT[16] as two backbone GNN layers to test the compatibility of our system. All the GNN models have $l=2$ layers. The GNN layers are followed by an activation ReLU function and a dropout function with a probability 0.01. The GAT layer has four attention heads. The output dimension and the hidden dimension are 16. All the models are trained using the Adam optimizer. The learning rate $lr$ is set to be $0.01$. The privacy parameter $\epsilon$ is set to be $2$. The GNN trainer trains the model for 300 epochs. The experiments are done with an Intel Core i7-10700 CPU clocked at 2.90GHz, an 8GB-memory NVIDIA RTX 3070, and 16GB memory.

We first evaluate the performance of our system in supervised settings to complete a label classification task. We uniformly sample the vertices into training, validation, and test sets for all the datasets with 50%, 25%, and 25% ratios. The label with the maximum probability is chosen and compared with the ground truth to compute the classification accuracy.

Then we conduct experiments in unsupervised settings to complete a link prediction task. We uniformly sample the edges into training, validation, and test sets for all the datasets with 80%, 5%, and 15% ratios. Each link is predicted with a given probability and compared with the ground truth to compute the ROC-AUC score [44], which is the probability that a classifier will assign a randomly chosen positive instance with a higher probability of being positive than a randomly chosen negative instance. We prefer models with higher scores.

VIII-C Comparison Methods

We compare our methods with centralized GNN network models, a local differential private GNN system (LPGNN[13]), and a naive federated GNN system.

• •

Centralized GNN network models take a complete global graph as input to a GNN model. Both the edge information and the node features are accessible to the server.

• •

LPGNN protects node features and labels with locally $\epsilon_{x}$ and $\epsilon_{y}$ differential privacy accordingly. However, it assumes that the server owns the graph structure. Although it is proposed in an environment where privacy is less restricted than ours, we can still compare the model’s prediction performance with Lumos. In the experiments, we set $\epsilon_{x}=2$ and $\epsilon_{y}=1$. Since LPGNN is proposed in supervised settings, we do not measure its performance in unsupervised scenarios.

• •

Naive FedGNN system noises graph statistics to ensure local differential privacy. It uses Gaussian Mechanism[45] to noise features and Randomized Response[46] to noise adjacency matrix and labels. The devices send the noised ego networks to the server to train GNN upon the noised graph.

VIII-D Performance Results

VIII-D1 Supervised Learning

The results are shown in Fig.3. Lumos merely loses a 16.29% accuracy upon Facebook dataset and 14.73% upon LastFM dataset compared to centralized GCN. On the other hand, Lumos merely loses a 16.30% accuracy upon Facebook dataset and 15.76% upon LastFM dataset compared to centralized GAT. This shows that Lumos performs close to centralized GNN. On Facebook dataset, Lumos outperforms LPGNN with a 6.44% accuracy increase for GCN and a 5.10% increase for GAT. On LastFM dataset, Lumos outperforms LPGNN with a 12.26% accuracy increase for GCN and an 7.62% increase for GAT. The result shows that Lumos embeds vertices more representative than LPGNN does with more privacy restrictions, particularly for datasets with excessive classes since LPGNN noises label to upload them to the server while Lumos processes original labels locally. Lumos performs much better than naive FedGNN does. On Facebook dataset, Lumos outperforms naive FedGNN with a relatively 74.29% accuracy increase for the GCN model and 42.13% for the GAT model. On LastFM, Lumos outperforms naive FedGNN with a relatively 52.85% accuracy increase for GCN model and 32.62% for the GAT model. This imply that our Lumos resolves the issue caused by federation of graph.

VIII-D2 Unsupervised Learning

Fig.4 presents the results. Lumos merely loses a 7.13% AUC score upon Facebook dataset and a 3.60% AUC score upon LastFM compared to centralized GCN. On the other hand, Lumos merely loses a 9.12% AUC score upon Facebook dataset and a 4.59% AUC score upon LastFM compared to GAT. Lumos performs much better than naive FedGNN does. On Facebook dataset, Lumos outperforms naive FedGNN with a relatively 22.94% AUC score increase for the GCN model and 22.03% for the GAT model. On LastFM, Lumos outperforms naive FedGNN with a relatively 19.72% accuracy increase for GCN model and 19.60% for the GAT model. This imply that our Lumos resolves the issue caused by federation of graph.

VIII-E Sensitivity Analysis of Privacy Parameter $\epsilon$

Figure 5 illustrates the effect of privacy parameter $\epsilon$ upon the model performance of Lumos. For supervised learning, raising $\epsilon$ from 0.5 to 1, 2, and 4 results in relatively 5.13%, 9.23%, and 10.26% accuracy increases on Facebook dataset and relatively 9.24%, 14.85% and 16.82% accuracy increases on LastFM dataset. For unsupervised learning, raising $\epsilon$ from 0.5 to 1, 2, and 4 results in relatively 8.88%, 15.04%, and 17.14% AUC score increases on Facebook dataset and 9.59%, 16.37% and 18.93% AUC score increase on LastFM dataset. Both plots show that Lumos with larger $\epsilon$ performs better as the feature encoder with small $\epsilon$ protects more privacy by deviating the output features more from the original. Moreover, Lumos is robust to variation in large $\epsilon$ values.

VIII-F Ablation Study

We perform the ablation study by replacing two essential components in Lumos with naive implementation to demonstrate their effectiveness. Lumos without virtual nodes, referred to as Lumos w.o. VN, takes the original ego network as the input to the tree-based GNN trainer. Lumos without tree trimming, referred to as Lumos w.o. TT, uses all the vertices in the ego network to construct a tree by skipping the tree trimming process.

VIII-F1 Effect of two modules on accuracy

Fig.6 presents the accuracy performance comparsion of Lumos with these two approaches. Lumos without virtual nodes performs the worst. In supervised learning, Lumos outperforms the one without virtual nodes with a 13.73% accuracy increase for the GCN model, 13.10% for the GAT model on Facebook dataset, and a 16.36% accuracy increase for the GCN model and 15.70% for GAT model on LastFM. In unsupervised learning, Lumos outperforms the one without virtual nodes with a 8.26% AUC score increase for the GCN model, 8.36% for the GAT model on Facebook, and a 8.99% AUC score increase for the GCN model and 7.69% for the GAT model on LastFM. The figures imply that Lumos successfully improves the representation by adding virtual nodes and enlarging the local graphs. Lumos performs very close to Lumos without tree trimming with relative accuracy and AUC score differences less than 0.01%. The slight differences indicate that Lumos is still expressive despite tree trimming since it ensures that every neighboring pair exists in at least one tree.

VIII-F2 Effectiveness in balancing the workload

Tree constructor influences not only embedding representativeness but also systematic performances by trimming trees to balance workloads across devices. Therefore, we specifically reveal its effect on system performance. We compare the workload distribution with and without tree trimming in Facebook and LastFM datasets. We measure workload using the number of selected neighboring vertices in the device. Without trimming, the workload is the original degree value in the graph. Fig.7 illustrates that the CDF of workloads of Lumos no longer has a heavy tail which Lumos without tree trimming has. In Facebook dataset, the maximal workload with tree trimming is 39, while the maximum without trimming is more significant than 150. In LastFM dataset, the maximal workload with trimming is 16, while the maximum without trimming is more significant than 100. The CDF plots show that Lumos successfully reduces those devices with large degree values and addresses workload imbalance.

VIII-F3 Effectiveness in reducing system cost

We measure the effect of the tree constructor by quantifying how well the tree constructor improves the system performance. Fig.8 illustrates how tree trimming affects the overall systematic performance of Lumos. Fig.8a presents the average number of inter-device communication rounds in one epoch in a tree-based GNN trainer. On Facebook dataset, Lumos with trimming saves 34.19% communication rounds per local device per epoch for supervised learning while it saves 27.34% rounds for unsupervised learning. On LastFM dataset, Lumos with trimming saves 43.02% rounds for supervised learning while it saves 36.80% rounds for unsupervised learning. Fig.8b presents the average training time per epoch in tree-based GNN trainer. On Facebook dataset, Lumos with trimming saves 13.32% training time per epoch for supervised learning while it saves 10.34% time for unsupervised learning. On LastFM dataset, Lumos with trimming saves 36.38% training time for supervised learning while it saves 10.90% for unsupervised learning. Fig.8 shows that our tree constructor with neighbor selection improves the system in terms of communication cost and training time by reducing the workloads in those devices with large degree values.

IX Conclusion

Federated GNN is an important learning problem that studies efficient graph data processing in privacy preserving environment. Existing studies on federated GNN seldom protect the local node degree. We propose the first federated GNN framework, called Lumos, to protect graph statistics in a node-separated setting. We design a novel tree constructor to enhance the expressive power of the original ego network. We propose a MCMC-based algorithm to balance the workload across different devices. We design a tree-based GNN trainer to train the constructed tree with features protected. Experiments have shown that our model outperforms the state-of-art framework in accuracy and system footprints. Lumos satisfies the most natural graph data privacy need in mobile applications and systems, and with a great potential in the emerging decentralized applications. The authors have provided public access to their code at https://github.com/panqy1998/Lumos.

Acknowledgement

This work is supported in part by SJTU Global Strategic Partnership Fund (2021 SJTU-HKUST). Lingyang Chu’s work is supported in part by the NSERC Discovery Grant Program, the CIHR Grant Program, and the McMaster Start-up Grant. We further thank the anonymous reviewers for their inspiring comments, which help us to improve the quality of this paper.