Graph Sparsification via Mixture of Graphs

## Abstract

Abstract Graph Neural Networks (GNNs) have demonstrated superior performance across various graph learning tasks but face significant computational challenges when applied to large-scale graphs. One effective approach to mitigate these challenges is graph sparsification, which involves removing non-essential edges to reduce computational overhead. However, previous graph sparsification methods often rely on a single global sparsity setting and uniform pruning criteria, failing to provide customized sparsification schemes for each node’s complex local context.
In this paper, we introduce Mixture-of-Graphs (MoG), leveraging the concept of Mixture-of-Experts (MoE), to dynamically select tailored pruning solutions for each node. Specifically, MoG incorporates multiple sparsifier experts, each characterized by unique sparsity levels and pruning criteria, and selects the appropriate experts for each node. Subsequently, MoG performs a mixture of the sparse graphs produced by different experts on the Grassmann manifold to derive an optimal sparse graph. One notable property of MoG is its entirely local nature, as it depends on the specific circumstances of each individual node. Extensive experiments on four large-scale OGB datasets and two superpixel datasets, equipped with five GNN backbones, demonstrate that MoG (I) identifies subgraphs at higher sparsity levels ( 8.67 % ∼ 50.85 % similar-to percent 8.67 percent 50.85 8.67\%\sim 50.85\% 8.67 % ∼ 50.85 % ), with performance equal to or better than the dense graph, (II) achieves 1.47 − 2.62 × 1.47-2.62\times 1.47 - 2.62 × speedup in GNN inference with negligible performance drop, and (III) boosts “top-student” GNN performance ( 1.02 % ↑ ↑ percent 1.02 absent 1.02\%\uparrow 1.02 % ↑ on RevGNN+ ogbn-proteins and 1.74 % ↑ ↑ percent 1.74 absent 1.74\%\uparrow 1.74 % ↑ on DeeperGCN+ ogbg-ppa ). The source code is
anonymously available at https://github.com/yanweiyue/MoG .

## 1 Introduction

Graph Neural Networks (GNNs) (Sun et al., ; Zhou et al., ) have become prominent for confronting graph-related learning tasks, including social recommendation (Wu et al., ; Yu et al., ), fraud detection (Sun et al., ; Wang et al., ; Cheng et al., ), drug design (Zhang & Liu, ), and many others (Wu et al., ; Sun et al., ). The superiority of GNNs stems from iterative *aggregation* and *update* processes. The former accumulates embeddings from neighboring nodes via sparse matrix-based operations (e.g., sparse-dense matrix multiplication (SpMM) and sampled dense-dense matrix multiplication (SDDMM) (Fey & Lenssen, ; Wang et al., )), and the latter updates the central nodes’ embeddings using dense matrix-based operations (e.g., MatMul) (Fey & Lenssen, ; Wang et al., ). SpMM typically contributes the most substantial part ($\sim$70%) to the computational demands (Liu et al., ; Zhang et al., ), influenced largely by the graph’s scale. Nevertheless, large-scale graphs are widespread in real-world scenarios (Wang et al., ; Jin et al., ; Zhang et al., ), leading to substantial computational burdens, which hinder the efficient processing of features during the training and inference, posing headache barriers to deploying GNNs in the limited resources environments.

Figure: Figure 1: (Left) We illustrated the $k$-hop neighborhood expansion rates for nodes 6 and 14, which is proportional to the amount of message they receive as the GNN layers deepen; (Middle) The local patterns of different nodes vary, hence the attributions of edge pruning may also differ. For instance, pruning $(v_{1},v_{2})$ might be due to its non-bridge identity, while pruning $(v_{5},v_{6})$ could be attributed to it non-homophilic nature; (Right) The overview of our proposed MoG.
Refer to caption: x1.png

To conquer the above challenge, graph sparsification (Chen et al., ; Hashemi et al., ) has recently seen a revival as it directly reduces the aggregation process associated with SpMM (Liu et al., ; Zhang et al., ) in GNNs. Specifically, graph sparsification is a technique that approximates a given graph by creating a sparse subgraph with a subset of vertices and/or edges. Since the execution time of SpMM is directly related to the number of edges in the graph, this method can significantly accelerate GNN training or inference. Existing efforts such as UGS (Chen et al., ), DSpar (Liu et al., ), and AdaGLT (Zhang et al., ) have achieved notable successes, with some maintaining GNN performance even with up to 40% edge sparsity.

Beyond serving as a computational accelerator, the purpose of graph sparsification extends further. Another research line leverages graph sparsification as a performance booster to remove task-irrelevant edges and pursue highly performant and robust GNNs (Zheng et al., ). Specifically, it is argued that due to uncertainty and complexity in data collection, graph structures are inevitably redundant, biased, and noisy (Li et al., ). Therefore, employing graph sparsification can effectively facilitate the evolution of graph structures towards cleaner conditions (Zheng et al., ; Luo et al., ), and finally boost GNN performance.

However, existing sparsification methods, namely sparsifiers, whether aimed at achieving higher sparsity or seeking enhanced performance, often adopt a rigid, global approach to conduct graph sparsification, thus suffering from the inflexibility in two aspects:

- ❶
Inflexibility of sparsity level. Previous sparsifiers globally score all edges uniformly and prune them based on a preset sparsity level (Chen et al., ). However, as shown in Figure 1 (Left), the degrees of different nodes vary, which leads to varying rates of $k$-hop neighborhood expansion. This phenomenon, along with prior work on node-wise aggregation (Lai et al., ; Wang et al., ), suggests that different nodes require customized sparsity levels tailored to their specific connectivity and local patterns.
- ❷
Inflexibility of sparsity criteria. Previous sparsifiers often operate under a unified guiding principle, such as pruning non-bridge edges (Wang et al., ), non-homophilic edges (Gong et al., ), or edges with low effective resistance (Spielman & Srivastava, ; Liu et al., ), among others. However, as illustrated in Figure 1 (Middle), the context of different nodes varies significantly, leading to varied rationales for edge pruning. Therefore, it is essential to select appropriate pruning criteria tailored to the specific circumstances of each node to customize the pruning process effectively.

Based on these observations and reflections, we propose the following challenge: Can we customize the sparsity level and pruning criteria for each node, in the meanwhile ensuring the efficiency of graph sparsification? Towards this end, we propose a novel graph sparsifier dubbed Mixture of Graphs (MoG). It comprises multiple sparsifier experts, each equipped with distinct pruning criteria and sparsity settings, as in Figure 1 (Right). Throughout the training process, MoG dynamically selects the most suitable sparsifier expert for each node based on its neighborhood properties. This fosters specialization within each MoG expert, focusing on specific subsets of nodes with similar neighborhood contexts.
After each selected expert prunes the 1-hop subgraph of the central nodes and outputs its sparse version, MoG seamlessly integrates these sparse subgraphs on the Grassmann manifold in an expert-weighted manner, thereby forming an optimized sparse graph.

We validate the effectiveness of MoG through a comprehensive series of large-scale tasks. Experiments conducted across six datasets and three GNN backbones showcase that MoG can ❶ effectively locate well-performing sparse graphs, maintaining GNN performance losslessly at satisfactory graph sparsity levels ($8.67\%\sim 50.85\%$), and even only experiencing a $1.65\%$ accuracy drop at $69.13\%$ sparsity on ogbn-proteins; ❷ achieve a tangible $1.47\sim 2.62\times$ inference speedup with negligible performance drop; and ❸ boost ROC-AUC by $1.81\%$ on ogbg-molhiv, $1.02\%$ on ogbn-proteins and enhances accuracy by $0.95\%$ on ogbn-arxiv compared to the vanilla backbones.

## 2 Technical Backgound

#### Notations & Problem Formulation

We consider an undirected graph $\mathcal{G}=\{\mathcal{V},\mathcal{E}\}$, with $\mathcal{V}$ as the node set and $\mathcal{E}$ the edge set. The node features of $\mathcal{G}$ is represented as $\mathbf{X}\in\mathbb{R}^{N\times F}$, where $N=|\mathcal{V}|$ signifies the total number of nodes in the graph. The feature vector for each node $v_{i}\in\mathcal{V}$, with $F$ dimensions, is denoted by $x_{i}=\mathbf{X}[i,\cdot]$. An adjacency matrix $\mathbf{A}\in\{0,1\}^{N\times N}$ is utilized to depict the inter-node connectivity, where $\mathbf{A}[i,j]=1$ indicates an edge $e_{ij}\in\mathcal{E}$, and 0 0 otherwise. For our task of graph sparsification, the core objective is to identify a subgraph $\mathcal{G}_{\text{sub}}$ given a sparsity ratio $s\%$:

$$ $\mathcal{G}^{\text{sub}}=\{\mathcal{V},\mathcal{E}\setminus\mathcal{E}^{\prime }\},\;s\%=\frac{|\mathcal{E}^{\prime}|}{|\mathcal{E}|},$ (1) $$

where $\mathcal{G}^{\text{sub}}$ only modifies the edge set $\mathcal{E}$ without altering the node set $\mathcal{V}$, and $\mathcal{E}^{\prime}$ denotes the removed edges, and $s\%$ represents the ratio of removed edges.

#### Graph Neural Networks

Graph neural networks (GNNs) (Wu et al., ) have become pivotal for learning graph representations, achieving benchmark performances in various graph tasks at node-level (Xiao et al., ), edge-level (Sun et al., ), and graph-level (Liu et al., ). At the node-level, two of the most famous frameworks are GCN (Kipf & Welling, ) and GraphSAGE (Hamilton et al., ), which leverages the message-passing neural network (MPNN) framework (Gilmer et al., ) to aggregate and update node information iteratively. For edge-level and graph-level tasks, GCN and GraphSAGE can be adapted by simply incorporating a predictor head or pooling layers. Nevertheless, there are still specialized frameworks like SEAL (Zhang & Chen, ) and Neo-GNN (Yun et al., ) for link prediction, and DiffPool (Ying et al., ) and PNA (Corso et al., ) for graph classification. Regardless of the task, MPNN-style GNNs generally adhere to the following paradigm:

$$ $\mathbf{h}_{i}^{(l)}=\text{{COMB}}\left(\mathbf{h}_{i}^{(l-1)},\text{{AGGR}}\{ \mathbf{h}_{j}^{(k-1)}:v_{j}\in\mathcal{N}(v_{i})\}\right),\;0\leq l\leq L$ (2) $$

where $L$ is the number of GNN layers, $\mathbf{h}_{i}^{(0)}=\mathbf{x}_{i}$, and $\mathbf{h}_{i}^{(l)}(1\leq l\leq L)$ denotes $v_{i}$’s node embedding at the $l$-th layer. AGGR($\cdot$) and COMB($\cdot$) represent functions used for aggregating neighborhood information and combining ego- and neighbor-representations, respectively.

#### Graph Sparsification

Graph sparsification methods can be categorized by their utility into two main types: computational accelerators and performance boosters. Regarding computational accelerators, early works aimed at speeding up traditional tasks like graph partitioning/clustering often provide theoretical assurances for specific graph properties, such as pairwise distances (Althöfer et al., ), cuts (Abboud et al., ), eigenvalue distribution (Batson et al., ), and effective resistance (Spielman & Srivastava, ). More contemporary efforts focus on the GNN training and/or inference acceleration, including methods like SGCN (Li et al., ), GEBT (You et al., ), UGS (Chen et al., ), DSpar (Liu et al., ), and AdaGLT (Zhang et al., ). Regarding performance boosters, methods like NeuralSparse (Zheng et al., ) and PTDNet (Luo et al., ) utilize parameterized denoising networks to eliminate task-irrelevant edges. SUBLIME (Liu et al., ) and Nodeformer (Wu et al., ) also involve refining or inferring a cleaner graph structure followed by $k$-nearest neighbors ($k$NN) sparsification.

#### Mixture of Experts

The Mixture of Experts (MoE) concept (Jacobs et al., ) traces its origins to several seminal works (Chen et al., ; Jordan & Jacobs, ). Recently, the sparse MoE architecture (Shazeer et al., ; Lepikhin et al., ; Fedus et al., ; Clark et al., ) has regained attention due to its capacity to support the creation of vast (language) models with trillions of parameters (Clark et al., ; Hoffmann et al., ). Given its stability and generalizability, sparse MoE is now broadly implemented in modern frameworks across various domains, including vision (Riquelme et al., ), multi-modal (Mustafa et al., ), and multi-task learning (Ma et al., ; Zhu et al., ). As for graph learning, MoE has been explored for applications in graph classification (Hu et al., ), scene graph generation (Zhou et al., ), molecular representation (Kim et al., ), graph fairness (Liu et al., ), and graph diversity modeling (Wang et al., ).

## 3 Methodology

### 3.1 Overview

Figure 2 illustrates the workflow of our proposed MoG. Specifically, for an input graph, MoG first decomposes it into 1-hop ego graphs for each node. For each node and its corresponding ego graph, a routing network calculates the expert scores. Based on the router’s decisions, sparsifier experts with different sparsity levels and pruning criteria are allocated to different nodes. Ultimately, a mixture of graphs is obtained based on the weighted consensus of the sparsifier experts. In the following sections, we will first detail how to route different sparsifiers in Section 3.2, then describe how to explicitly model various sparsifier experts in Section 3.3 and how to ensemble the sparse graphs output by sparsifiers on the Grassmann manifold in Section 3.4. Finally, the overall optimization process and complexity analysis of MoG is placed in Section 3.5.

Figure: Figure 2: The overview of our proposed method. MoG primarily comprises ego-graph decomposition, expert routing, sparsifier customization, and the final graph mixture. For simplicity, we only showcase three pruning criteria including Jaccard similarity, gradient magnitude, and effective resistance.
Refer to caption: x2.png

### 3.2 Routing to Diverse Experts

Following the classic concept of a (sparsely-gated) mixture-of-experts (Zhao et al., ), which assigns the most suitable expert(s) to each input sample, MoG aims to allocate the most appropriate sparsity level and pruning criteria to each input node. To achieve this, we first decompose the input graph $\mathcal{G}=\{\mathcal{V},\mathcal{E}\}$ into 1-hop ego graphs centered on different nodes, denoted as $\{\mathcal{G}^{(1)},\mathcal{G}^{(2)},\cdots,\mathcal{G}^{(N)}\}$, where $\mathcal{G}^{(i)}=\{\mathcal{V}^{(i)},\mathcal{E}^{(i)}\}$, $\mathcal{V}^{(i)}=\{v_{j}|v_{j}\in\mathcal{N}(v_{i})\}$, $\mathcal{E}^{(i)}=\{e_{ij}|(v_{i},v_{j})\in\mathcal{E}\}$. Assuming we have $K$ sparsifier experts, for each node $v_{i}$ and its corresponding ego graph $\mathcal{G}^{(i)}$, we aim to select $k$ most suitable sparsifiers. We employ the noisy top-$k$ gating mechanism following Shazeer et al. ():

$$ $\displaystyle\Psi(\mathcal{G}^{(i)})=\operatorname{Softmax}(\operatorname{TopK }(\psi(x_{i}),k)),$ (3) $\displaystyle\psi(x_{i})=x_{i}W_{g}+\epsilon\cdot\operatorname{Softplus}(x_{i} W_{n}),$ (4) $$

where $\psi(x_{i})\in\mathbb{R}^{K}$ is the calculated scores of $v_{i}$ for total $K$ experts, $\operatorname{TopK}(\cdot)$ is a selection function that outputs the largest $k$
values, and $\Psi(\mathcal{G}^{(i)})\in\mathbb{R}^{k}=[E^{(i)}_{1},E^{(i)}_{2},\cdots,E^{(i
)}_{k}]$ represents those for selected $k$ experts. In $\Psi(\mathcal{G}^{(i)})$, $\epsilon\in\mathcal{N}(0,1)$ denotes the standard Gaussian noise, $W_{g}\in\mathbb{R}^{K\times F}$ and $W_{n}\in\mathbb{R}^{K\times F}$ are trainable parameters that learn clean and noisy scores, respectively.

After determining the appropriate experts, we proceed to generate different sparse graphs with diverse sparsifiers. We denote each sparsifier by $\kappa(\cdot)$, which takes in a dense graph $\mathcal{G}$ and outputs a sparse one $\tilde{\mathcal{G}}=\kappa(\mathcal{G})$. Based on this, for each node $v_{i}$ and its ego graph $\mathcal{G}^{(i)}$, the routing network selects $k$ experts that produce $k$ sparse ego graphs. Notably, sparsifiers differ in their pruning rates (i.e. the proportion of the edges to be removed) and the pruning criteria, which will be detailed in Section 3.3. MoG’s dynamic selection of different sparsifiers for each node aids in identifying pruning strategies truly adapted to the node’s local context. Formally, the mixture of $k$ sparse graphs can be written as:

$$ $\widehat{\mathcal{G}^{(i)}}=\text{{ESMB}}(\{\widetilde{\mathcal{G}}^{(i)}_{m} \}_{m=1}^{k}),\;\;\widetilde{\mathcal{G}}^{(i)}_{m}=\kappa^{m}(\mathcal{G}^{(i )}),$ (5) $$

where $\text{{ESMB}}(\cdot)$ is a combination function that receives $k$ sparse graphs and ideally outputs an emsemble version $\widehat{\mathcal{G}^{(i)}}=\{\widehat{\mathcal{V}^{(i)}},\widehat{\mathcal{E}
^{(i)}}\}$ that preserves their desirable properties.
It is noteworthy that, MoG can seamlessly integrate with any GNN backbone after obtaining each node’s sparse ego graph. Specifically, we modify the aggregation method in Equation 2 as follows:

$$ $\mathbf{h}_{i}^{(l)}=\text{{COMB}}\left(\mathbf{h}_{i}^{(l-1)},\text{{AGGR}}\{ \mathbf{h}_{j}^{(k-1)}:v_{j}\in\widehat{\mathcal{V}^{(i)}}\}\right).$ (6) $$

MoG acts as a plug-and-play module that can be pre-attached to any GNN architecture, leveraging multi-expert sparsification to enhance GNNs with (1) performance improvements from removing task-irrelevant edges (validated in Section 4.3); (2) resistance to high graph sparsity through precise and customized sparsification (validated in Section 4.2). The remaining questions now are: how can we design explicitly different sparsifiers? and further, how can we develop an effective combination function that integrates the sparse graphs from different experts?

### 3.3 Customized Sparsifier Modeling

With the workflow of MoG in mind, in this section, we will delve into how to design sparsifiers driven by various pruning criteria and different levels of sparsity. Revisiting graph-related learning tasks, their objective can generally be considered as learning $P(\mathbf{Y}|\mathcal{G})$, which means learning the distribution of the target $\mathbf{Y}$ given an input graph. Based on this, a sparsifier $\kappa(\cdot)$ can be formally expressed as follows:

$$ $\displaystyle P(\mathbf{Y}|\mathcal{G})$ $\displaystyle\approx\sum_{g\in\mathbb{S}_{\mathcal{G}}}P(\mathbf{Y}\;|\;\tilde {\mathcal{G}})P(\tilde{\mathcal{G}}\;|\;\mathcal{G})$ $\displaystyle\approx\sum_{g\in\mathbb{S}_{\mathcal{G}}}Q_{\Theta}(\mathbf{Y}\; |\;\tilde{\mathcal{G}})Q_{\kappa}(\tilde{\mathcal{G}}\;|\;\mathcal{G})$ (7) $$

where $\mathbb{S}_{\mathcal{G}}$ is a class of sparsified subgraphs of $\mathcal{G}$. The second term in Equation 7 aims to approximate the distribution of $\mathbf{Y}$ using the sparsified graph $\tilde{\mathcal{G}}$ as a bottleneck, while the third term uses two approximation functions $Q_{\Theta}$ and $Q_{\kappa}$ for $P(\mathbf{Y}\;|\;\tilde{\mathcal{G}})$ and $P(\tilde{\mathcal{G}}\;|\;\mathcal{G})$ parameterized by $\Theta$ and $\kappa$ respectively. The parameter $\Theta$ typically refers to the parameters of the GNN, while the sparsifier $\kappa(\cdot)$, on the other hand, is crafted to take an ego graph $\mathcal{G}^{(i)}$ and output its sparsified version $\tilde{\mathcal{G}^{(i)}}$, guided by a specific pruning paradigm $C$ and sparsity $s^{m}\%$:

$$ $\kappa^{m}(\mathcal{G}^{(i)})=\{\mathcal{V}^{(i)},\mathcal{E}^{(i)}\setminus \mathcal{E}_{p}^{(i)}\},\;\mathcal{E}_{p}^{(i)}=\operatorname{TopK}\left(-C^{m }(\mathcal{E}),\lceil|\mathcal{E}^{(i)}|\times s^{m}\%\rceil\right),$ (8) $$

where $C^{m}(\cdot)$ acts as the $m$-th expert’s scoring function that evaluates edge importance. We leverage long-tail gradient estimation (Liu et al., ) to ensure the $\operatorname{TopK}(\cdot)$ operator is differentiable. Furthermore, to ensure different sparsity criteria drive the sparsifier, we implement $C^{m}(\cdot)$ as follows:

$$ $\displaystyle C^{m}(e_{ij})=\operatorname{FFN}\left(x_{i},x_{j},c(e_{ij}) \right),\;c^{m}(e_{ij})\in\left\{\begin{array}[]{c}\text{Degree: }\left(| \mathcal{N}(v_{i})+\mathcal{N}(v_{j})|\right)/2\\ \text{Jaccard Similarity: }\frac{|\mathcal{N}(v_{i})\cap\mathcal{N}(v_{j})|}{| \mathcal{N}(v_{i})\cup\mathcal{N}(v_{j})|}\\ \text{ER: }(e_{i}-e_{j})^{T}\mathbf{L}^{-1}(e_{i}-e_{j})\\ \text{Gradient Magnitude: }|\partial\mathcal{L}/\partial e_{ij}|\end{array} \right\},$ (9) $$

where $\operatorname{FFN}(\cdot)$ is a feed-forward network, $c^{m}(e_{ij})$ represents the prior guidance on edge significance. By equipping different sparsifiers with various priors and sparsity levels, we can customize the most appropriate pruning strategy for each node’s local scenario. In practice, we select four widely-used pruning criteria including edge degree (Seo et al., ), Jaccard similarity (Murphy, ; Satuluri et al., ), effective resistance (Spielman & Srivastava, ; Liu et al., ) and gradient magnitude (Wan & Schweitzer, ; Zhang et al., ). Details regarding these criteria and their implementations are in Appendix B.

### 3.4 Graph Mixture on Grassmann Manifold

After employing $k$ sparsifiers driven by different criteria and sparsity levels, we are in need of an effective mechanism to ensemble these $k$ sparse subgraphs and maximize the aggregation of their advantages. A straightforward approach is voting or averaging (Sagi & Rokach, ); however, such simple merging may fail to capture the intricate relationships among multi-view graphs (Kang et al., ), potentially resulting in the loss of advantageous properties from all experts.
Inspired by recent advances in manifold representations (Dong et al., ; Bendokat et al., ), we develop a subspace-based sparse graph ensembling mechanism. We first provide the definition of the Grassmann manifold (Bendokat et al., ) as follows:

###### Definition 1 (Grassmann manifold) .

Grassmann manifold $Gr(n,p)$ is the space of $n$-by-$p$ matrices (e.g., $\mathbf{M}$) with
orthonormal columns, where $0\leq p\leq n$, i.e.,

$$ $Gr(n,p)=\left\{\mathbf{M}|\mathbf{M}\in\mathbb{R}^{n\times p},\mathbf{M}^{\top }\mathbf{M}=\mathbf{I}\right\}.$ (10) $$

According to Grassmann manifold theory, each orthonormal matrix represents a unique subspace and thus corresponds to a distinct point on the Grassmann manifold (Lin et al., ). This applies to the eigenvector matrix of the normalized Laplacian matrix ($\mathbf{U}=\mathbf{L}[:,:p]\in\mathbb{R}^{n\times p}$), which comprises the first $p$ eigenvectors and is orthonormal (Merris, ), and thereby can be mapped onto the Grassmann manifold.

Consider the $k$ sparse subgraphs $\{\widetilde{\mathcal{G}}^{(i)}_{m}\}_{m=1}^{k}$, their subspace representations are $\{\mathbf{U}^{(i)}_{m}\in\mathbb{R}^{|\mathcal{N}(v_{i})|\times p}\}_{m=1}^{k}$. We aim to identify an oracle subspace $\mathbf{U}^{(i)}$ on the Grassmann manifold, which essentially represents a graph, that serves as an informative combination of $k$ base graphs. Formally, we present the following objective function:

$$ $\displaystyle\min_{\mathbf{U^{(i)}}\in\mathbb{R}^{|\mathcal{N}(v_{i})|\times p }}\sum_{m=1}^{k}\left(\underbrace{\operatorname{tr}(\mathbf{U^{(i)}}^{\top} \mathbf{L}_{m}\mathbf{U}^{(i)})}_{\textrm{(1) node connectivity}}+\underbrace{ \overbrace{E^{(i)}_{m}}^{\text{expert score}}\cdot d^{2}(\mathbf{U}^{(i)}, \mathbf{U}^{(i)}_{m})}_{\textrm{(2) subspace distance}}\right),\operatorname{s .t.}\mathbf{U^{(i)}}^{\top}\mathbf{U^{(i)}}=\mathbf{I}$ (11) $$

where $\operatorname{tr}(\cdot)$ calculates the trace of matrices, $\mathbf{L}_{m}$ is the graph Laplacian of $\mathcal{G}^{(i)}_{m}$, $d^{2}(\mathbf{U}_{1},\mathbf{U}_{2})$ denotes the project distance between two subspaces (Dong et al., ), and $E^{(i)}_{m}$ is the expert score for the $m$-th expert, calculated by the routing network $\Psi$, which determines which expert’s subspace the combined subspace should more closely align with. In Equation 11, the first term is designed to preserve the original node connectivity based on spectral embedding, and the second term controls that individual subspaces are
close to the final representative subspace $\mathbf{U}^{(i)}$. Using the Rayleigh-Ritz Theorem (Jia & Stewart, ), we provide a closed-form solution for Equation 11 and obtain the graph Laplacian of the ensemble sparse graph $\widehat{\mathcal{G}^{(i)}}$ as follows:

$$ $\widehat{\mathbf{L}^{(i)}}=\sum_{m=1}^{k}\left(\mathbf{L}_{m}-E_{m}^{(i)}\cdot \mathbf{U^{(i)}}^{\top}\mathbf{U^{(i)}}\right).$ (12) $$

We provide detailed derivations and explanations for Equations 11 and 12 in Appendix C. Consequently, we can reformulate the function $\text{{ESMB}}(\cdot)$ in Equation 5 as follows:

$$ $\text{{ESMB}}(\{\widetilde{\mathcal{G}}^{(i)}_{m}\}_{m=1}^{k})=\{\mathbf{D}- \widehat{\mathbf{L}^{(i)}},\mathbf{X}^{(i)}\}=\left\{\mathbf{D}-\sum_{m=1}^{k} \left(\mathbf{L}_{m}-E_{m}^{(i)}\cdot\mathbf{U^{(i)}}^{\top}\mathbf{U^{(i)}} \right),\mathbf{X}^{(i)}\right\}.$ (13) $$

On the Grassmann manifold, the subspace ensemble effectively captures the beneficial properties of each expert’s sparse graph. After obtaining the final version of each node’s ego-graph, $\widehat{\mathcal{G}^{(i)}}=\{\widehat{\mathbf{A}^{(i)}},\mathbf{X}^{(i)}\}$, we conduct a post-sparsification step as the graph ensembled on the Grassmann manifold can become dense again. Specifically, we obtain the final sparsity $s^{(i)}\%$ for $v_{i}$ by weighting the sparsity of each expert and sparsifying $\widehat{\mathcal{G}^{(i)}}$.

$$ $\widehat{\mathcal{G}^{(i)}}\leftarrow\{\operatorname{TopK}(\widehat{\mathbf{A} ^{(i)}},|\mathcal{E}^{(i)}|\times s^{(i)}\%),\mathbf{X}^{(i)}\},\;s^{(i)}\%= \frac{1}{k}\sum_{m=1}^{k}s^{m}\%.$ (14) $$

These post-sparsified $\widehat{\mathcal{G}^{(i)}}$ are then reassembled together into $\widehat{\mathcal{G}}\leftarrow\{\widehat{\mathcal{G}^{(1)}},\widehat{\mathcal
{G}^{(2)}},\cdots,\widehat{\mathcal{G}^{(|\mathcal{V}|)}}\}$. Ultimately, the sparsified graph $\widehat{\mathcal{G}}$ produced by MoG can be input into any MPNN (Gilmer et al., ) or graph transformer (Min et al., ) architectures for end-to-end training.

###### Definition 1 (Grassmann manifold) .

### 3.5 Training and Optimization

#### Additional Loss Functions

Following classic MoE works (Shazeer et al., ; Wang et al., ), we introduce an expert importance loss to prevent MoG from converging to a trivial solution where only a single group of experts is consistently selected:

$$ $\operatorname{Importance}(\mathcal{V})=\sum_{i=1}^{|\mathcal{V}|}\sum_{j=1}^{k }E^{(i)}_{m},\;\;\mathcal{L}_{\text{importance}}(\mathcal{V})=\operatorname{CV }(\operatorname{Importance}(\mathcal{V}))^{2},$ (15) $$

where $\operatorname{Importance}(\mathcal{V})$ represents the sum of each node’s expert scores across the node-set, $\operatorname{CV}(\cdot)$ calculates the coefficient of variation, and $\mathcal{L}_{\text{importance}}$ ensures the variation of experts. Therefore, the final loss function combines both task-specific and MoG-related losses, formulated as follows:

$$ $\mathcal{L}=\mathcal{L}_{\text{task}}+\lambda\cdot\mathcal{L}_{\text{ importance}},$ (16) $$

where $\lambda$ is a hand-tuned scaling factor, with its sensitivity analysis placed in Section 4.4.

#### Complexity Analysis

To better illustrate the effectiveness and clarity of MoG, we provide a comprehensive algorithmic table in Appendix D and detailed complexity analysis in Appendix E. To address concerns regarding the runtime efficiency of MoG, we have included an empirical analysis of efficiency in Section 4.5.

## 4 Experiments

In this section, we conduct extensive experiments to answer the following research questions:
(RQ1) Can MoG effectively help GNNs combat graph sparsity?
(RQ2) Does MoG genuinely accelerate the GNN inference?
(RQ3) Can MoG help boost GNN performance?
(RQ4) How sensitive is MoG to its key components and parameters?

### 4.1 Experiment Setup

#### Datasets and Backbones

We opt for four large-scale OGB benchmarks (Hu et al., ), including ogbn-arxiv, ogbn-proteins and ogbn-products for node classification, and ogbg-ppa for graph classification. The dataset splits are given by (Hu et al., ). Additionally, we choose two superpixel datasets, MNIST and CIFAR-10 (Knyazev et al., ). We select GraphSAGE (Hamilton et al., ), DeeperGCN (Li et al., ), and PNA (Corso et al., ) as the GNN backbones. More details are provided in Appendix F.

#### Parameter Configurations

For MoG, we adopt the $m=4$ sparsity criteria outlined in Section 3.3, assigning $n=3$ different sparsity levels $\{s_{1},s_{2},s_{3}\}$ to each criterion, resulting in a total of $K=m\times n=12$ experts. We select $k=2$ sparsifier experts for each node, and set the loss scaling factor $\lambda=1e-2$ across all datasets and backbones. By adjusting the sparsity combination, we can control the global sparsity of the entire graph. We present more details on parameter settings in Section F.4, and a recipe for adjusting the graph sparsity in Section F.6.

### 4.2 MoG as Graph Sparsifier (RQ1 & RQ2)

To answer RQ1 and RQ2, we comprehensively compare MoG with eleven widely-used topology-guided sparsifiers and five semantic-guided sparsifiers, as outlined in Table 1, with more detailed explanations in Section F.5. The quantitative results on five datasets are shown in Tables 1, 10, 9, 12 and 11 and the efficiency comparison is in Figure 3. We give the following observations (Obs.):

**Table 1: Node classification performance comparison to state-of-the-art sparsification methods. All methods are trained using GraphSAGE, and the reported metrics represent the average of five runs. We denote methods with ${\dagger}$ that do not have precise control over sparsity; their performance is reported around the target sparsity $\pm 2\%$. “Sparsity %” refers to the ratio of removed edges as defined in Section 2. “OOM” and “OOT” denotes out-of-memory and out-of-time, respectively.**
|  | Dataset | ogbn-arxiv (Accuracy$\uparrow$) | ogbn-proteins (ROC-AUC$\uparrow$) |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Sparsity % | 10 | 30 | 50 | 70 | 10 | 30 | 50 | 70 |  |
| Topology-guided | Random | 70.03↓1.46 | 68.40↓3.09 | 64.32↓7.17 | 61.18↓10.3 | 76.72↓0.68 | 75.03↓2.37 | 73.58↓3.82 | 72.30↓5.10 |
| Rank Degree^† (Voudigari et al., ) | 68.13↓3.36 | 67.01↓4.48 | 65.58↓5.91 | 62.17↓9.32 | 77.47↑0.07 | 76.15↓1.25 | 75.59↓1.81 | 74.23↓3.17 |  |
| Local Degree^† (Hamann et al., ) | 68.94↓2.55 | 67.20↓4.29 | 65.45↓6.04 | 65.59↓5.90 | 76.20↓1.20 | 76.05↓1.35 | 76.09↓1.31 | 72.88↓4.52 |  |
| Forest Fire^† (Leskovec et al., ) | 68.39↓3.10 | 68.10↓3.39 | 67.36↓4.13 | 65.22↓6.27 | 76.50↓0.90 | 75.37↓2.03 | 74.29↓3.11 | 72.11↓5.29 |  |
| G-Spar (Murphy, ) | 71.30↓0.19 | 69.29↓2.20 | 65.56↓5.93 | 65.49↓6.00 | 77.38↓0.02 | 77.36↓0.04 | 76.02↓1.38 | 75.89↓1.51 |  |
| LSim^† (Satuluri et al., ) | 69.22↓2.27 | 66.15↓5.34 | 61.07↓10.4 | 60.32↓11.2 | 76.83↓0.57 | 76.01↓1.39 | 74.83↓2.57 | 73.65↓3.75 |  |
| SCAN (Xu et al., ) | 71.55↑0.06 | 69.27↓2.22 | 65.14↓6.35 | 64.72↓6.77 | 77.60↑0.20 | 76.88↓0.52 | 76.19↓1.21 | 74.32↓3.08 |  |
| ER (Spielman & Srivastava, ) | 71.63↑0.14 | 69.48↓2.01 | 69.00↓2.49 | 67.15↓4.34 | OOT |  |  |  |  |
| DSpar (Liu et al., ) | 71.23↓0.26 | 68.50↓2.99 | 64.79↓6.70 | 63.11↓8.38 | 77.34↓0.06 | 77.06↓0.34 | 76.38↓1.02 | 75.49↓1.91 |  |
| Semantic-guided | UGS^† (Chen et al., ) | 68.77↓2.72 | 66.30↓5.19 | 65.72↓5.77 | 63.10↓8.39 | 76.80↓0.60 | 75.46↓1.94 | 73.28↓4.12 | 73.31↓4.09 |
| GEBT (You et al., ) | 69.04↓2.45 | 65.29↓6.20 | 65.88↓5.61 | 65.62↓5.87 | 76.30↓1.10 | 76.17↓1.23 | 74.43↓2.97 | 74.12↓3.28 |  |
| MGSpar (Wan & Schweitzer, ) | 70.22↓1.27 | 69.13↓2.36 | 68.27↓3.22 | 66.55↓4.94 | OOM |  |  |  |  |
| ACE-GLT^† (Wang et al., ) | 71.88↑0.39 | 70.14↓1.35 | 68.08↓3.41 | 67.04↓4.45 | 77.59↑0.19 | 76.14↓1.26 | 75.43↓1.97 | 73.28↓4.12 |  |
| WD-GLT^† (Hui et al., ) | 71.92↑0.43 | 70.21↓1.28 | 68.30↓3.19 | 66.57↓4.92 | OOM |  |  |  |  |
| AdaGLT (Zhang et al., ) | 71.22↓0.27 | 70.18↓1.31 | 69.13↓2.36 | 67.02↓4.47 | 77.49↑0.09 | 76.76↓1.64 | 76.00↓2.40 | 75.44↓2.96 |  |
| MoG (Ours)^† | 71.93${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.44}}$ | 70.53${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{0.96}}$ | 69.06↓2.43 | 67.31${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{4.18}}$ | 77.78${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.38}}$ | 77.49${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.09}}$ | 76.46${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{0.94}}$ | 76.12${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{1.28}}$ |  |
| Whole Dataset | 71.49±0.01 | 77.40±0.1 |  |  |  |  |  |  |  |

#### Obs. ❶ MoG demonstrates superior performance in both transductive and inductive settings.

As shown in Tables 1, 2, 9, 10 and 11, MoG outperforms other sparsifiers in both transductive and inductive settings. Specifically, for node classification tasks, MoG achieves a $0.09\%$ performance improvement while sparsifying $30\%$ of the edges on ogbn-proteins+GraphSAGE. Even when sparsifying $50\%$ of the edges on ogbn-proteins+DeeperGCN, the ROC-AUC only drops by $0.81\%$. For graph classification tasks, MoG can remove up to $50\%$ of the edges on MNIST with a $0.14\%$ performance improvement, surpassing other sparsifiers by $0.99\%\sim 12.97\%$ in accuracy.

#### Obs. ❷ Different datasets and backbones exhibit varying sensitivities to sparsification.

As shown in Tables 1 and 10, despite ogbn-proteins being relatively insensitive to sparsification, sparsification at extremely high levels (e.g., $70\%$) causes more performance loss for GraphSAGE compared to DeeperGCN, with the former experiencing a $2.28\%$ drop and the latter only $1.07\%$, which demonstrates the varying sensitivity of different GNN backbones to sparsification. Similarly, we observe in Table 2 that the MNIST dataset shows a slight accuracy increase even with $50\%$ sparsification, whereas the ogbg-ppa dataset suffers a $1.86\%$ performance decline, illustrating the different sensitivities to sparsification across graph datasets.

#### Obs. ❸ MoG can effectively accelerate GNN inference with negligible performance loss.

Figure 3 illustrates the actual acceleration effects of MoG compared to other baseline sparsifiers. It is evident that MoG achieves $1.6\times$ lossless acceleration on ogbn-proteins+DeeperGCN and ogbn-products+GraphSAGE, meaning the performance is equal to or better than the vanilla backbone. Notably, on ogbn-products+DeeperGCN, MoG achieves $3.3\times$ acceleration with less than a $1.0\%$ performance drop. Overall, MoG provides significantly superior inference acceleration compared to its competitors.

**Table 2: Graph classification performance comparison to state-of-the-art sparsification methods. The reported metrics represent the average of five runs.**
|  | Dataset | MNIST + PNA (Accuracy $\uparrow$) | ogbn-ppa + DeeperGCN (Accuracy $\uparrow$) |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Sparsity % | 10 | 30 | 50 | 70 | 10 | 30 | 50 | 70 |  |
| Topology-guided | Random | 94.61↓2.74 | 87.23↓10.1 | 84.82↓12.5 | 80.07↓17.3 | 75.44↓1.65 | 73.81↓4.09 | 71.97↓5.12 | 69.62↓7.47 |
| Rank Degree^† (Voudigari et al., ) | 96.42↓0.93 | 94.23↓3.12 | 92.36↓4.99 | 89.20↓8.15 | 75.81↓1.28 | 74.99↓2.10 | 74.12↓2.97 | 70.68↓6.41 |  |
| Local Degree^† (Hamann et al., ) | 95.95↓1.40 | 93.37↓3.98 | 90.11↓7.24 | 86.24↓11.1 | 76.43↓0.66 | 75.87↓1.22 | 72.11↓4.98 | 69.93↓7.16 |  |
| Forest Fire^† (Leskovec et al., ) | 96.75↓0.60 | 95.42↓1.93 | 95.03↓2.32 | 93.10↓4.25 | 76.38↓0.71 | 75.33↓1.76 | 73.18↓3.91 | 71.49↓5.60 |  |
| G-Spar (Murphy, ) | 97.10↓0.25 | 96.59↓0.76 | 94.36↓2.99 | 92.48↓4.87 | 77.68↑0.59 | 73.90↓3.19 | 69.52↓7.57 | 68.10↓8.99 |  |
| LSim^† (Satuluri et al., ) | 95.79↓1.56 | 92.14↓5.21 | 92.29↓5.06 | 91.95↓5.40 | 76.04↓1.05 | 74.40↓2.69 | 72.78↓4.31 | 68.21↓8.88 |  |
| SCAN (Xu et al., ) | 95.81↓1.54 | 93.48↓3.87 | 90.18↓7.17 | 86.48↓10.9 | 75.23↓1.86 | 75.18↓1.91 | 72.48↓4.61 | 71.11↓5.98 |  |
| ER (Spielman & Srivastava, ) | 94.77↓2.58 | 93.91↓3.44 | 93.45↓3.90 | 91.07↓6.28 | 77.94↑0.85 | 75.15↓1.94 | 73.23↓3.86 | 72.74↓4.35 |  |
| DSpar (Liu et al., ) | 94.97↓2.38 | 93.80↓3.55 | 92.23↓5.12 | 90.48↓6.87 | 76.33↓0.76 | 73.37↓3.72 | 72.98↓4.11 | 70.77↓6.32 |  |
| Semantic | ICPG (Sui et al., ) | 97.69↑0.34 | 97.39↑0.04 | 96.80↓0.55 | 93.77↓3.58 | 77.36↑0.27 | 75.24↓1.85 | 73.18↓3.91 | 71.09↓6.00 |
| AdaGLT (Zhang et al., ) | 97.31↓0.04 | 96.58↓0.77 | 94.14↓3.21 | 92.08↓5.27 | 76.22↓0.87 | 73.54↓3.55 | 70.10↓6.99 | 69.28↓7.81 |  |
|  | MoG (Ours)^† | 97.80${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.45}}$ | 97.74${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.39}}$ | 97.79${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.44}}$ | 95.30${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{2.05}}$ | 78.43${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{1.34}}$ | 77.90${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.81}}$ | 75.23${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{1.86}}$ | 73.09${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{4.00}}$ |
| Whole Dataset | 97.35±0.07 | 77.09±0.04 |  |  |  |  |  |  |  |

Figure: Figure 3: The trade-off between inference speedup and model performance for MoG and other sparsifiers. The first and second rows represent results on GraphSAGE and DeeperGCN, respectively. The gray pentagon represents the performance of the original GNN without sparsification.
Refer to caption: x3.png

### 4.3 MoG as Performance Booster (RQ3)

In the context of RQ3, MoG is developed to augment GNN performance by selectively removing a limited amount of noisy and detrimental edges, while simultaneously preventing excessive sparsification that could degrade GNN performance. Consequently, we uniformly set the sparsity combination to $\{90\%,85\%,80\%\}$. We combine MoG with state-of-the-art GNNs on both node-level and graph-level tasks. The former include RevGNN (Li et al., ) and GAT+BoT (Wang et al., ), which rank fourth and seventh, respectively, on the ogbn-proteins benchmark, and the latter include PAS (Wei et al., ) and DeeperGCN (Li et al., ), ranking fourth and sixth on the ogbn-ppa benchmark. We observe from Table 3:

#### Obs. ❹ MoG can assist the “top-student” backbones to learn better.

Despite RevGNN and PAS being high-ranking backbones for ogbn-proteins and ogbg-ppa, MoG still achieves non-marginal performance improvements through moderate graph sparsification: $1.02\%\uparrow$ on RevGNN+ogbn-proteins and $1.74\%\uparrow$ on DeeperGCN+ogbg-ppa. This demonstrates that MoG can effectively serve as a plugin to boost GNN performance by setting a relatively low sparsification rate.

**Table 3: Node classification results on ogbn-proteins with RevGNN and GAT+BoT and graph classification results on ogbg-ppa with PAS and DeeperGCN. Mean and standard deviation values from five random runs are presented.**
|  | ogbn-proteins (ROC-AUC$\uparrow$) | ogbg-ppa (Accuracy$\uparrow$) |  |  |
| --- | --- | --- | --- | --- |
| Model | RevGNN | GAT+BoT | PAS | DeeperGCN |
| w/o MoG | 88.14$\pm$ 0.24 | 88.09 $\pm$ 0.16 | 78.28 $\pm$ 0.24 | 77.09 $\pm$ 0.04 |
| w/ MoG | 89.04 $\pm$ 0.72 | 88.72 $\pm$ 0.50 | 78.66 $\pm$ 0.47 | 78.43 $\pm$ 0.19 |
| (Sparsity: 9.2%) | (Sparsity: 12.7%) | (Sparsity: 6.6%) | (Sparsity: 10.8%) |  |

### 4.4 Sensitivity Analysis (RQ4)

To answer RQ4, we perform a sensitivity analysis on the two most important parameters in MoG: the number of selected experts $k$ and the expert importance loss coefficient $\lambda$. We compared the performance of MoG when choosing different numbers of experts per node, as outlined in Section 4.4. The effect of different scaling factors $\lambda$ on ogbn-proteins+DeeperGCN is shown in Section 4.4. Based on the results of the above sensitivity analysis, we observe that:

#### Obs. ❺ Sparse expert selection helps customized sparsification.

It can be observed FROM Section 4.4 that the optimal $k$ varies with the level of graph sparsity. At lower sparsity (10%), $k=1$ yields relatively good performance. However, as sparsity increases to 50%, model performance peaks at $k=4$, suggesting that in high sparsity environments, more expert opinions contribute to better sparsification. Notably, when $k$ increases to 6, MoG’s performance declines, indicating that a more selective approach in sparse expert selection aids in better model generalization. For a balanced consideration of performance and computational efficiency, we set $k=2$ in all experiments. We further provide sensitivity analysis results of paramter $k$ on more datasets, as shown in Section G.2.

#### Obs. ❻ Sparsifier load balancing is essential.

We conduct a sensitivity analysis of the expert importance loss coefficient $\lambda$. A larger $\lambda$ indicates greater variation in the selected experts. As shown in Section 4.4, $\lambda=0$ consistently resulted in the lowest performance, as failing to explicitly enforce variation among experts leads to the model converging to a trivial solution with the same set of experts (Wang et al., ; Shazeer et al., ). Conversely, $\lambda=1e-1$ performed slightly better than $\lambda=1e-2$ at higher sparsity levels, supporting the findings in Obs. 5 that higher sparsity requires more diverse sparsifier experts.

Figure: Figure 4: Sensitivity study on parameter $k$, i.e., how many experts are chosen per node. The results are reported based on ogbn-arxiv+GraphSAGE.
Refer to caption: x4.png

Figure: Table 4: Sensitivity study on scaling factor $\lambda$. The results are reported on ogbn-proteins+DeeperGCN.

**Table 5: Running time efficiency comparison on ogbn-products+GraphSAGE. We consistently set $n=4,k=2$, corresponding to utilizing 4 pruning criteria and selecting 2 experts for each node, and vary $m\in\{1,2,3\}$ to check how the training cost grows with $m$ increasing.**
| Sparsity | 30% | 50% |  |  |
| --- | --- | --- | --- | --- |
| Metric | Per-epoch Time (s) | Accuracy (%) | Per-epoch Time (s) | Accuracy (%) |
| Random | 18.71$\pm$ 0.14 | 74.21$\pm$ 0.28 | 15.42 $\pm$ 0.24 | 71.08$\pm$ 0.34 |
| AdaGLT | 23.55$\pm$ 0.20 | 77.30 $\pm$ 0.54 | 21.68 $\pm$ 0.26 | 74.38 $\pm$ 0.79 |
| MoG($m=1,K=3$) | 20.18$\pm$ 0.14 | 77.75 $\pm$ 0.22 | 18.19 $\pm$ 0.30 | 76.10 $\pm$ 0.49 |
| MoG($m=2,K=6$) | 21.25$\pm$ 0.22 | 78.23 $\pm$ 0.29 | 19.70 $\pm$ 0.30 | 76.43 $\pm$ 0.49 |
| MoG($m=3,K=12$) | 23.19$\pm$ 0.18 | 78.15 $\pm$ 0.32 | 20.83 $\pm$ 0.29 | 76.98 $\pm$ 0.49 |

### 4.5 Efficiency Analysis and Ablation Study (RQ4)

#### Efficiency Analysis

To verify that MoG can achieve better results with less additional training cost than the previous SOTA methods, we compare the accuracy and the time efficiency of MoG with AdaGLT on ogbn-product+GraphSAGE, as outlined in Table 5. We have:

#### Obs. ❼ MoG can achieve better accuracy with less additional training cost.

It is evident in Table 5 that MoG incurs less additional training cost compared to AdaGLT while achieving significant improvements in sparsification performance. More importantly, we demonstrate that with $k=2$, MoG does not incur significantly heavier training burdens as the number of sparsifiers increases. Specifically, at $s\%=50\%$, the difference in per epoch time between MoG ($K=3$) and MoG ($K=12$) is only $2.63$ seconds, consistent with the findings of mainstream sparse MoE approaches (Wang et al., ).

#### Ablation Study

We test three different settings of $\epsilon$ (in Equation 3) on Ogbn-Arxiv+GraphSAGE: (1) $\epsilon\sim\mathcal{N}(0,\mathbf{I})$, (2) $\epsilon=0$, and (3) $\epsilon=0.2$, presented in Table 15. Our key finding is that randomness in gating networks consistently benefits our model. More results and detailed analysis can be found in Section G.3.

## 5 Conclusion & Limitation

In this paper, we introduce a new graph sparsification paradigm termed MoG, which leverages multiple graph sparsifiers, each equipped with distinct sparsity levels and pruning criteria. MoG selects the most suitable sparsifier expert based on each node’s local context, providing a customized graph sparsification solution, followed by an effective mixture mechanism on the Grassmann manifold to ensemble the sparse graphs produced by various experts. Extensive experiments on four large-scale OGB datasets and two superpixel datasets have rigorously demonstrated the effectiveness of MoG. A potential limitation of MoG is its current reliance on 1-hop decomposition to represent each node’s local context. The performance of extending this approach to $k$-hop contexts remains unexplored, suggesting a possible direction for future research.

## Appendix A Notations

We conclude the commonly used notations throughout the manuscript in Table 6.

**Table 6: The notations that are commonly used in the manuscript.**
| Notation | Definition |
| --- | --- |
| $\mathcal{G}=\left\{\mathcal{V},\mathcal{E}\right\}=\left\{\mathbf{A},\mathbf{X<br>}\right\}$ | Input graph |
| $\mathbf{A}$ | Input adjacency matrix |
| $\mathbf{X}$ | Node feature matrix |
| $\mathbf{L}$ | Graph Laplacian matrix |
| $\texttt{COMB}(\cdot)$ | GNN ego-node transformation function |
| $\texttt{AGGR}(\cdot)$ | GNN message aggregation function |
| $\texttt{ESMB}(\cdot)$ | Sparse graph combination function |
| $s\%$ | Sparsity ratio (the ratio of removed edges) |
| $v_{i}$ | The $i$-th node in $\mathcal{G}$ |
| $x_{i}$ | Node feature vector for $v_{i}$ |
| $\mathcal{G}^{(i)}$ | The 1-hop ego-graph for $v_{i}$ |
| $\phi(\mathcal{G}^{(i)})$ | Routing network |
| $K$ | The number of total sparsifier experts |
| $k$ | The number of selected sparsifier experts per node |
| $W_{g},W_{n}$ | Trainable parameters in the routing network |
| $\kappa(\mathcal{G})$ | A graph sparsifier |
| $\mathcal{G}^{(i)}_{m}$ | The sparse ego-graph of $v_{i}$ produced by the $m$-th graph sparsifier |
| $\widehat{\mathcal{G}^{(i)}}=\{\widehat{\mathcal{V}^{(i)}},\widehat{\mathcal{E}<br>^{(i)}}\}$ | The ensemble sparse graph produced by MoG for $v_{i}$ |
| $\mathcal{E}_{p}^{(i)}$ | Edges removed surrounding $v_{i}$ |
| $c^{m}(e_{ij})$ | Prior guidance on edge importance $e_{ij}$ |

## Appendix B Deatils on Pruning Criteria

In this section, we will thoroughly explain the four pruning criteria we selected and the rationale behind these choices.

- •
Edge degree of $e_{ij}$ is defined as follows:
$\operatorname{Degree}\;(e_{ij})=\frac{1}{2}\left(|\mathcal{N}(v_{i})+\mathcal{
N}(v_{j})|\right).$
(17)
Previous methods (Wang et al., ; Seo et al., ) have explicitly or implicitly used edge degree for graph sparsification. Intuitively, edges with higher degrees are more replaceable. (Wang et al., ) further formalizes this intuition from the perspective of bridge edges.
- •
Jaccard Similarity (Murphy, ) measures the similarity between two sets by computing the portion of shared neighbors between two nodes ($v_{i}$and $v_{j}$), as defined below:
$\operatorname{JaccradSimilarity}\;v_{i},v_{j})=\frac{|\mathcal{N}(v_{i})\cap
\mathcal{N}(v_{j})|}{|\mathcal{N}(v_{i})\cup\mathcal{N}(v_{j})|}.$
(18)
Jaccard similarity is widely used for its capacity for detecting clusters, hubs, and outliers on social networks (Murphy, ; Xu et al., ; Satuluri et al., ).
- •
Effective Resistance, derived from the analogy to electrical circuits, is applied to graphs where edges represent resistors. The effective resistance of an edge is defined as the potential difference generated when a unit current is introduced at one vertex and withdrawn from the other. Once the effective resistance is calculated, a sparsified subgraph can be constructed by selecting edges with probabilities proportional to their effective resistances. Notably, (Spielman & Srivastava, ) proved that the quadratic form of the Laplacian for such sparsified graphs closely approximates that of the original graph. Consequently, the following inequality holds for the sparsified subgraph with high probability:
$\forall\bm{x}\in\mathbb{R}^{|\mathcal{V}|}\ \ \ (1-\epsilon)\bm{x}^{T}\mathbf{
L}\bm{x}\leq\bm{x}^{T}\tilde{\mathbf{L}}\bm{x}\leq(1+\epsilon)\bm{x}^{T}
\mathbf{L}\bm{x},$
(19)
where $\tilde{\mathbf{L}}$ is the Laplacian of the sparsified graph, and $\epsilon>0$ is a small number. The insight is that effective resistance reflects the significance of an edge. Effective resistance aims to preserve the quadratic form of the graph Laplacian. This property makes it suitable for applications relying on the quadratic form of the graph Laplacian, such as min-cut/max-flow problems. For computation simplicity, we do not directly utilize the definition of effective resistance, and use its approximation version (Liu et al., ).
- •
Gradient Magnitude, a widely used pruning criterion, is prevalent not only in the field of graph sparsification but also in classical neural network pruning. Numerous studies (Lee et al., ; Tessera et al., ; Dettmers et al., ) leverage gradient magnitude to estimate parameter importance. Specifically for graph sparsification, MGSpar (Wan & Schweitzer, ) was the first to propose using meta-gradient to estimate edge importance. We consider gradient magnitude a crucial indicator of the graph’s topological structure during training. Therefore, we explicitly design some sparsifier experts to focus on this information.

## Appendix C Graph Mixture on Grassmann Manifold

In this section, we detail how we leverage the concept of Grassmann Manifold to effectively combine different sparse (ego-)graphs output by various sparsifiers.

According to Equation 10, each orthonormal matrix represents a unique subspace and thus corresponds to a distinct point on the Grassmann manifold (Lin et al., ). This applies to the eigenvector matrix of the normalized Laplacian matrix ($\mathbf{U}=\mathbf{L}[:,:p]\in\mathbb{R}^{n\times p}$), which comprises the first $p$ eigenvectors and is orthonormal (Merris, ), and thereby can be mapped onto the Grassmann manifold. Additionally, each row of the eigenvector matrix encapsulates the spectral embedding of each node in a p-dimensional space, where adjacent nodes have similar embedding vectors. This subspace representation, summarizing graph information, is applicable to various tasks such as clustering, classification, and graph merging (Dong et al., ).

In the context of MoG, we aim to efficiently find the final version that aggregates all the excellent properties of each point’s $k$ versions of sparse ego-graph $\{\widetilde{\mathcal{G}}^{(i)}_{m}\}_{m=1}^{k}$ on the Grassmann Manifold. Moreover, this should guided by the expert scores computed by the routing network in Section 3.2. Let $\mathbf{D}_{m}$ and $\mathbf{A}_{m}$ denote the degree matrix and the adjacency matrix for $\widetilde{\mathcal{G}}^{(i)}_{m}$ (we omit the superscript $(\cdot)^{(i)}$ denoting $v_{i}$ for simplicity in the subsequent expressions), then the normalized graph Laplacian is defined as:

$$ $\mathbf{L}_{m}=\mathbf{D}_{m}^{-\frac{1}{2}}(\mathbf{D}_{m}-\mathbf{A}_{m}) \mathbf{D}_{m}^{\frac{1}{2}}.$ (20) $$

Given the graph Laplacian $\mathbf{L}_{m}$ for each sparse graph, we calculate the spectral embedding matrix $\mathbf{U}_{m}$ through trace minimization:

$$ $\min_{\mathbf{U}_{m}\in\mathbb{R}^{|\mathcal{N}(v_{m})|\times p}}\operatorname {tr}\;(\mathbf{U}_{m}^{\top}\mathbf{L}_{m}\mathbf{U}_{m}),\;\;\operatorname{s. t.}\;\mathbf{U}_{m}^{\top}\mathbf{U}_{m}=\mathbf{I},$ (21) $$

which can be solved by the Rayleigh-Ritz theorem. As mentioned above, each point on the Grassmann manifold can be represented by an orthonormal matrix $\mathbf{Y}\in\mathbb{R}^{|\mathcal{N}(v_{i})|\times p}$ whose columns span the corresponding $p$-dimensional subspace in $\mathbb{R}^{|\mathcal{N}(v_{i})|\times p}$. The distance between such subspaces can be computed as a set of principal angles $\{\theta_{i}\}_{i=1}^{k}$ between these subspaces. (Dong et al., ) showed that the projection distance between two subspaces $\mathbf{Y}_{1}$ and $\mathbf{Y}_{2}$ can be represented as a separate trace minimization problem:

$$ $d^{2}_{\text{proj}}(\mathbf{Y}_{1},\mathbf{Y}_{2})=\sum_{i=1}^{p}\sin^{2}{ \theta_{i}}=k-\operatorname{tr}\;(\mathbf{Y}_{1}\mathbf{Y}_{1}^{\top}\mathbf{Y }_{2}\mathbf{Y}_{2}^{\top}).$ (22) $$

Based on this, we further define the projection of the final representative subspace $\mathbf{U}$ and the $k$ sparse candidate subspace $\{\mathbf{U}_{m}\}_{m=1}^{k}$:

$$ $d^{2}_{\text{proj}}(\mathbf{U},\{\mathbf{U}_{m}\}_{m=1}^{k})=\sum_{m=1}^{k}d^{ 2}_{\text{proj}}(\mathbf{U},\mathbf{U}_{m})=p\times k-\sum_{m=1}^{k} \operatorname{tr}\;(\mathbf{U}\mathbf{U}^{\top}\mathbf{U}_{m}\mathbf{U}_{m}^{ \top}),$ (23) $$

which ensures that individual subspaces are close to the final representative subspace $\mathbf{U}$.

Finally, to maintain the original vertex connectivity from all $k$ sparse ego-graphs and emphasize the connectivity relationship from more reliable sparsifiers (with higher expert scores), we propose the following objective function:

$$ $\min_{\mathbf{U}_{m}\in\mathbb{R}^{|\mathcal{N}(v_{m})|\times p}}\sum_{m=1}^{k }E^{(i)}_{m}\left(p\times k-\sum_{m=1}^{k}\operatorname{tr}\;(\mathbf{U} \mathbf{U}^{\top}\mathbf{U}_{m}\mathbf{U}_{m}^{\top})\right),$ (24) $$

where $E^{(i)}_{m}$ represents the expert score of the node $v_{i}$’s $m$-th sparsifier expert. Based on Equations 21 and 24, we present the overall objective:

$$ $\min_{\mathbf{U^{(i)}}\in\mathbb{R}^{|\mathcal{N}(v_{i})|\times p}}\sum_{m=1}^ {k}\left(\underbrace{\operatorname{tr}(\mathbf{U^{(i)}}^{\top}\mathbf{L}_{m} \mathbf{U}^{(i)})}_{\textrm{(1) node connectivity}}+\underbrace{E^{(i)}_{m} \cdot d^{2}(\mathbf{U}^{(i)},\mathbf{U}^{(i)}_{m})}_{\textrm{(2) subspace distance}}\right),\operatorname{s.t.}\mathbf{U^{(i)}}^{\top}\mathbf{U^{(i)}}= \mathbf{I}.$ (25) $$

For simplicity, we omit the superscript ^(i) in the following content. Substituting Equation 23 into Equation 25, we obtain:

$$ $\min_{\mathbf{U}}\sum_{m=1}^{k}\text{tr}(\mathbf{U}^{T}\mathbf{L}_{m}\mathbf{U })+E_{m}\cdot\left(p\times k-\sum_{m=1}^{k}\text{tr}(\mathbf{U}\mathbf{U}^{T} \mathbf{U}_{m}\mathbf{U}_{m}^{T})\right),\text{s.t.}\mathbf{U}^{T}\mathbf{U}= \mathbf{I}.$ (26) $$

Further simplification by neglecting constant terms like $E_{m}\times p\times k$ yields:

$$ $\min_{\mathbf{U}}\sum_{m=1}^{k}\text{tr}(\mathbf{U}^{T}\mathbf{L}_{m}\mathbf{U })-E_{m}\cdot\sum_{m=1}^{k}\text{tr}(\mathbf{U}\mathbf{U}^{T}\mathbf{U}_{m} \mathbf{U}_{m}^{T}),\text{s.t.}\mathbf{U}^{T}\mathbf{U}=\mathbf{I}.$ (27) $$

Reorganizing the trace form of the second term, we obtain:

$$ $\min_{\mathbf{U}}\text{tr}\left[\mathbf{U}^{T}(\sum_{k=1}^{M}\mathbf{L}_{m}-E_ {m}\sum_{k=1}^{M}\mathbf{U}_{m}\mathbf{U}_{m}^{T})\mathbf{U}\right],\text{s.t. }\mathbf{U}^{T}\mathbf{U}=\mathbf{I}.$ (28) $$

At this point, the optimization problem essentially becomes a trace minimization problem, and thus the solution to this minimization problem is essentially the term between $\mathbf{U}^{T}$ and $\mathbf{U}$, which is:

$$ $\widehat{\mathbf{L}}=(\sum_{k=1}^{M}\mathbf{L}_{m}-E_{m}\sum_{k=1}^{M}\mathbf{ U}_{m}\mathbf{U}_{m}^{T})=\sum_{k=1}^{M}(\mathbf{L}_{m}-E_{m}\cdot\mathbf{U}_{ m}\mathbf{U}_{m}^{T}).$ (29) $$

Since computations involving the Grassmann manifold unavoidably entail eigenvalue decomposition, concerns about computational complexity may arise. However, given that MoG only operates mixtures on the ego-graph of each node, such computational burden is entirely acceptable. Specific complexity analyses are presented in Appendix E.

## Appendix D Algorithm Workflow

The algorithm framework is presented in Algo. 1.

Figure: Algorithm 1 Algorithm workflow of MoG

## Appendix E Complexity Analysis

In this section, we delve into a comprehensive analysis of the time and space complexity of MoG. Without loss of generality, we consider the scenario where MoG is applied to vanilla GCN. It is worth recalling that the forward time complexity of vanilla GCN is given by:

$$ $\mathcal{O}(L\times|\mathcal{E}|\times D+L\times|\mathcal{V}|\times D^{2}),$ (30) $$

where $L$ is the number of GNN layers, $|\mathcal{E}|$ and $|\mathcal{V}|$ denotes the number of edges and nodes, respectively, and $D$ is the hidden dimension. Similarly, the forward space complexity of GCN is:

$$ $\mathcal{O}(L\times|\mathcal{E}|+L\times D^{2}+L\times|\mathcal{V}|\times D)$ (31) $$

When MoG is applied to GCN, each sparsifier expert $\kappa(\cdot)$ essentially introduces additional complexity equivalent to that of an $\operatorname{FFN}(\cdot)$, as depicted in Equation 9. Incorporating the Sparse MoE-style structure, the forward time complexity of GCN+MoG becomes:

$$ $\mathcal{O}(L\times|\mathcal{E}|\times D+L\times|\mathcal{V}|\times D^{2}+k \times|\mathcal{E}|\times D\times D^{s}),$ (32) $$

where $D^{s}$ represents the hidden dimension of the feed-forward network in Equation 9 and $k$ denotes the number of selected experts. Similarly, the forward space complexity is increased to:

$$ $\mathcal{O}(L\times|\mathcal{E}|+L\times D^{2}+L\times|\mathcal{V}|\times D+k \times|\mathcal{E}|\times D\times D^{s}).$ (33) $$

It is noteworthy that we omit the analysis for the routing network, as its computational cost is meanwhile negligible compared to the cost of selected experts, since both $W_{g}\in\mathbb{R}^{K\times F}$ and $W_{n}\in\mathbb{R}^{K\times F}$ is in a much smaller dimension that the weight matrix $W\in\mathbb{R}^{F\times F}$ in GCN.

Furthermore, we present the additional complexity introduced by the step of graph mixture on the Grassmann manifold. For each center node’s $k$ sparse ego-graphs, we need to compute the graph Laplacian and the eigenvector matrix, which incurs an extra time complexity of $\mathcal{O}(k\times(\frac{|\mathcal{E}|}{|\mathcal{V}|})^{3})$; to compute the Laplacian $\widehat{\mathbf{L}^{(i)}}$ of the final ensemble sparse graph, an additional complexity of $\mathcal{O}(k\times(\frac{|\mathcal{E}|}{|\mathcal{V}|})^{2}\times p)$ is required. In the end, the complete time complexity of MoG is expressed as:

$$ $\mathcal{O}\left(\underbrace{L\times|\mathcal{E}|\times D+L\times|\mathcal{V}| \times D^{2}}_{\text{vanilla GCN}}+\underbrace{k\times|\mathcal{E}|\times D \times D^{s}}_{\text{sparsifier experts}}+\underbrace{k\left(\frac{|\mathcal{E }|}{|\mathcal{V}|}\right)^{3}+k\left(\frac{|\mathcal{E}|}{|\mathcal{V}|}\right )^{2}p}_{\text{graph mixture}}\right).$ (34) $$

To empirically verify that MoG does not impose excessive computational burdens on GNN backbones, we conduct experiments in Section 4.5 to compare the per-epoch time efficiency metric of MoG with other sparsifiers.

## Appendix F Experimental Details

### F.1 Dataset Statistics

We conclude the dataset statistics in Tab. 7

**Table 7: Graph datasets statistics.**
| Dataset | $\#$Graph | $\#$Node | $\#$Edge | $\#$Classes | Metric |
| --- | --- | --- | --- | --- | --- |
| Ogbn-ArXiv | 1 | 169,343 | 1,166,243 | 40 | Accuracy |
| Ogbn-Proteins | 1 | 132,534 | 39,561,252 | 2 | ROC-AUC |
| Ogbn-Products | 1 | 2,449,029 | 61,859,140 | 47 | Accuracy |
| Ogbg-PPA | 158,100 | 243.4 | 2,266.1 | 47 | Accuracy |
| mnist | 70,100 | 50.5 | 564.5 | 10 | Accuracy |
| cifar-10 | 60,000 | 117.6 | 914.0 | 10 | Accuracy |

### F.2 Evaluation Metrics

Accuracy represents the ratio of correctly predicted outcomes to the total predictions made. The ROC-AUC (Receiver Operating Characteristic-Area Under the Curve) value quantifies the probability that a randomly selected positive example will have a higher rank than a randomly selected negative example.

### F.3 Dataset Splits

For node-level tasks, the data splits for Ogbn-ArXiv, Ogbn-Proteins, and Ogbn-Products were provided by the benchmark (Hu et al., ). Specifically, for Ogbn-ArXiv, we train on papers published until 2017, validate on papers from 2018 and test on those published since 2019. For Ogbn-Proteins, protein nodes were segregated into training, validation, and test sets based on their species of origin. For Ogbn-Products, we sort the products according to their sales ranking and use the top 8% for training, next top 2% for validation, and the rest for testing.

For graph-level tasks, we follow (Hu et al., ) for Ogbg-PPA. Concretely, we adopt the species split, where the neighborhood graphs in the validation and test sets are extracted from protein association networks of species not encountered during training but belonging to one of the 37 taxonomic groups. This split stress-tests the model’s capacity to extract graph features crucial for predicting taxonomic groups, enhancing biological understanding of protein associations. For mnist and cifar-10, consistent with (Dwivedi et al., ), we split them to 55000 train/5000 validation/10000 test for MNIST, and 45000 train/5000 validation/10000 test for CIFAR10, respectively.
We report the test accuracy at the epoch with the best validation accuracy.

### F.4 Parameter Setting

#### Backbone Parameters

For node classification backbones, we utilize a 3-layer GraphSAGE with $\texttt{hidden_dim}\in\{128,256\}$. As for DeeperGCN, we set $\texttt{layer_num}=28$, $\texttt{block}=\texttt{res+}$, $\texttt{hidden_dim}=64$. The other configurations are the same as in [https://github.com/lightaime/deep_gcns_torch/tree/master/examples/ogb/ogbn_proteins](https://github.com/lightaime/deep_gcns_torch/tree/master/examples/ogb/ogbn_proteins). For graph classification backbones, we leverage a 4-layer PNA with $\texttt{hidden_dim}=300$. Rest configurations are the same as in [https://github.com/lukecavabarrett/pna](https://github.com/lukecavabarrett/pna).

#### MoG parameters

We adopt the $m=4$ sparsity criteria outlined in Section 3.3, assigning $n=3$ different sparsity levels $\{s_{1},s_{2},s_{3}\}$ to each criterion, resulting in a total of $K=m\times n=12$ experts. We select $k=2$ sparsifier experts for each node, and set the loss scaling factor $\lambda=1e-2$ across all datasets and backbones.

All the experiments are conducted on NVIDIA Tesla V100 (32GB GPU), using PyTorch and PyTorch Geometric framework.

### F.5 Sparsifier Baseline Configurations

- •
Topology-based sparsification
–
Rank Degree (Talati et al., ): The Rank Degree sparsifier initiates by selecting a random set of "seed" vertices. Then, the vertices with connections to these seed vertices are ranked based on their degree in descending order. Subsequently, the edges linking each seed vertex to its top-ranked neighbors are chosen and integrated into the sparsified graph. The newly added nodes in the graph act as new seeds for identifying additional edges. This iterative process continues until the target sparsification limit is attained. We utilize the implementation in (Chen et al., ).
–
Local Degree (Hamann et al., ): Local Degree sparsifier, similar to Rank Degree, incorporates edges to the top $\operatorname{deg}(v)^{\alpha}$ neighbors ranked by their degree in descending order, where $\alpha\in[0,1]$ represents the degree of sparsification.
–
Forest Fire (Leskovec et al., ): Forest fire assembles “burning” through edges probabilistically, and we use the implementation in (Staudt et al., ).
–
G-Spar (Murphy, ): G-Spar sorts the Jaccard scores globally and then selects the edges with the highest similarity score. We opt for the code from (Staudt et al., ).
–
Local Similarity (Satuluri et al., ): Local Similarity ranks edges using the Jaccard score and computes $\log(\operatorname{rank}(e_{ij}))/\log(\operatorname{deg}(e_{ij}))$ as the similarity score, and selects edges with the highest similarity scores. We utilize the implementation in (Chen et al., ).
–
SCAN (Spielman & Srivastava, ): SCAN uses structural similarity (called SCAN similarity) measures to detect clusters, hubs, and outliers. We utilize the implementation in (Chen et al., )
–
DSpar (Liu et al., ): DSpar is an extension of effective resistance sparsifier, which aims to reduce the high computational budget of calculating effective resistance through an unbiased approximation. We adopt their official implementation (Liu et al., ).
- •
Semantic-based sparsification
–
UGS (Chen et al., ): We utilize the official implementation from the authors. Notably, UGS was originally designed for joint pruning of model parameters and edges. Specifically, it sets separate pruning parameters for parameters and edges, namely the weight pruning ratio $p_{\theta}$ and the graph pruning ratio $p_{g}$. In each iteration, a corresponding proportion of parameters/edges is pruned. For a fairer comparison, we set $p_{\theta}=0\%$, while maintaining $p_{g}\in\{5\%,10\}$ (consistent with the original paper).
–
GEBT (You et al., ): GEBT, for the first time, discovered the existence of graph early-bird (GEB) tickets that emerge at the very early stage when sparsifying GCN graphs. (You et al., ) has proposed two variants of graph early bird tickets, and we opt for the graph-sparsification-only version, dubbed GEB Ticket Identification.
–
Meta-gradient sparsifier (Wan & Schweitzer, ): The Meta-gradient sparsifier prunes edges based on their meta-gradient importance scores, assessed over multiple training epochs. Since no official implementation is provided, we carefully replicated the results following the guidelines in the original paper.
–
ACE-GLT (Wang et al., ): ACE-GLT inherits the iterative magnitude pruning (IMP) paradigm from UGS. Going beyond UGS, it suggested mining valuable information from pruned edges/weights after each round of IMP, which in the meanwhile doubled the computational cost of IMP. We utilize the official implementation provided by (Wang et al., ), and set $p_{\theta}=0\%,p_{g}\in\{5\%,10\}$.
–
WD-GLT (Hui et al., ): WD-GLT also inherits the iterative magnitude pruning paradigm from UGS, so we also set $p_{\theta}=0\%,p_{g}\in\{5\%,10\%\}$ across all datasets and backbones. The perturbation ratio $\alpha$ is tuned among $\{0,1\}$. Since no official implementation is provided, we carefully reproduced the results according to the original paper.
–
AdaGLT (Zhang et al., ): AdaGLT revolutionizes the original IMP-based graph lottery ticket methodology into an adaptive, dynamic, and automated approach, proficient in identifying sparse graphs with layer-adaptive structures. We fix $\eta_{\theta}=0\%,\eta_{g}\in\{1e-6,1e-5,1e-4,1e-3,1e-2\},\omega=2$ across all datasets and backbones.

### F.6 Adjusting Graph Sparsity

In Table 8, we provide detailed guidelines on how to achieve the desired global sparsity by adjusting the three sparsity levels $\{s_{1},s_{2},s_{3}\}$ in MoG across six datasets.

**Table 8: The recipe for adjusting graph sparsity via different sparsifier combinations.**
| Datasets | $1-s_{1}$ | $1-s_{2}$ | $1-s_{3}$ | $k$ | $1-s\%$ |
| --- | --- | --- | --- | --- | --- |
| ogbn-arxiv | 1 | 0.9 | 0.8 | 2 | [88.0%,90.9%] |
| 0.8 | 0.7 | 0.5 | 2 | [69.0%,73.2%] |  |
| 0.6 | 0.5 | 0.3 | 2 | [49.5%,52.7%] |  |
| 0.5 | 0.3 | 0.15 | 2 | [27.1%, 31.6%] |  |
| ogbn-proteins | 1 | 0.9 | 0.8 | 2 | [86.1%,89.3%] |
| 0.8 | 0.7 | 0.6 | 2 | [65.1%,69.2%] |  |
| 0.6 | 0.5 | 0.4 | 2 | [45.2%,49.3%] |  |
| 0.4 | 0.3 | 0.2 | 2 | [29.2%,31.1%] |  |
| ogbn-products | 1 | 0.9 | 0.8 | 2 | [90.1%,93.2%] |
| 0.8 | 0.7 | 0.6 | 2 | [69.3%,72.0%] |  |
| 0.6 | 0.5 | 0.4 | 2 | [51.5%,54.9%] |  |
| 0.4 | 0.3 | 0.2 | 2 | [28.7%,36.0%] |  |
| mnist | 1 | 0.85 | 0.8 | 2 | [90.4%,92.7%] |
| 0.8 | 0.5 | 0.4 | 2 | [67.1%,68.3%] |  |
| 0.6 | 0.3 | 0.2 | 2 | [46.2%,49.3%] |  |
| 0.35 | 0.1 | 0.1 | 2 | [29.8%,31.3%] |  |
| cifar-10 | 1 | 0.85 | 0.8 | 2 | [90.6%,93.7%] |
| 0.8 | 0.5 | 0.4 | 2 | [67.5%,69.9%] |  |
| 0.6 | 0.3 | 0.2 | 2 | [47.7%,49.3%] |  |
| 0.35 | 0.1 | 0.1 | 2 | [30.1%,31.3%] |  |
| ogbg-ppa | 0.95 | 0.9 | 0.8 | 2 | [86.5%,88.9%] |
| 0.8 | 0.65 | 0.6 | 2 | [68.0%,70.1%] |  |
| 0.6 | 0.5 | 0.3 | 2 | [47.8%,48.9%] |  |
| 0.4 | 0.3 | 0.15 | 2 | [30.1%,33.6%] |  |

## Appendix G Addtional Experiment Results

### G.1 Results for RQ1

We report the performances of MoG and other sparsifiers on ogbn-products in Table 9.

**Table 9: Node classification performance comparison to state-of-the-art sparsification methods. All methods are trained using GraphSAGE, and the reported metrics represent the average of five runs. We denote methods with ${\dagger}$ that do not have precise control over sparsity; their performance is reported around the target sparsity $\pm 2\%$. We do not report results for sparsifiers like ER for OOT issues and those like UGS for their infeasibility in inductive settings (mini-batch training).**
|  | Dataset | ogbn-products (Accuracy $\uparrow$) |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Sparsity % | 10 | 30 | 50 | 70 |  |
| Topology | Random | 76.99↓1.05 | 74.21↓3.83 | 71.08↓6.96 | 67.24↓10.80 |
| Rank Degree^† (Voudigari et al., ) | 76.08↓1.96 | 74.26↓3.89 | 71.85↓6.19 | 70.66↓7.38 |  |
| Local Degree^† (Hamann et al., ) | 77.19↓1.58 | 76.40↓1.64 | 72.77↓5.27 | 72.48↓5.56 |  |
| G-Spar (Murphy, ) | 76.15↓1.89 | 74.20↓3.84 | 71.55↓6.49 | 69.42↓8.62 |  |
| LSim^† (Satuluri et al., ) | 77.96↓0.08 | 74.98↓2.06 | 72.67↓5.37 | 70.43↓7.61 |  |
| SCAN (Xu et al., ) | 76.30↓1.74 | 74.33↓3.71 | 71.25↓6.79 | 71.12↓6.92 |  |
| DSpar (Liu et al., ) | 78.25↑0.21 | 75.11↓2.93 | 74.57↓3.47 | 73.16↓4.88 |  |
| Sema | AdaGLT (Zhang et al., ) | 78.19↑0.15 | 77.30↓0.74 | 74.38↓3.66 | 73.04↓5.00 |
| MoG (Ours)^† | 78.77${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.73}}$ | 78.15${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.11}}$ | 76.98↓1.06 | 74.91${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{3.17}}$ |  |
| Whole Dataset | 78.04±0.31 |  |  |  |  |

**Table 10: Node classification performance comparison to state-of-the-art sparsification methods. All methods are trained using DeeperGCN, and the reported metrics represent the average of five runs. We denote methods with ${\dagger}$ that do not have precise control over sparsity; their performance is reported around the target sparsity $\pm 2\%$. “OOM” and “OOT” denotes out-of-memory and out-of-time, respectively.**
|  | Dataset | ogbn-arxiv (Accuracy $\uparrow$) |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Sparsity % | 10 | 30 | 50 | 70 |  |
| Topology-guided | Random | 70.66↓1.28 | 68.74↓3.20 | 65.38↓6.56 | 63.55↓8.39 |
| Rank Degree^† (Voudigari et al., ) | 69.44↓2.50 | 67.82↓4.12 | 65.08↓6.86 | 63.19↓8.75 |  |
| Local Degree^† (Hamann et al., ) | 68.77↓3.17 | 67.92↓4.02 | 66.10↓5.84 | 65.97↓5.97 |  |
| Forest Fire^† (Leskovec et al., ) | 68.70↓3.24 | 68.95↓3.99 | 67.23↓4.71 | 67.29↓4.65 |  |
| G-Spar (Murphy, ) | 70.57↓1.37 | 70.15↓1.79 | 68.77↓3.17 | 65.26↓6.68 |  |
| LSim^† (Satuluri et al., ) | 69.33↓2.61 | 67.19↓4.75 | 63.55↓8.39 | 62.20↓9.74 |  |
| SCAN (Xu et al., ) | 71.33↓0.61 | 69.22↓2.72 | 67.88↓4.06 | 64.32↓7.62 |  |
| ER (Spielman & Srivastava, ) | 71.33↓0.61 | 69.65↓2.29 | 69.08↓2.86 | 67.10↓4.84 |  |
| DSpar (Liu et al., ) | 71.65↓0.29 | 70.66↓1.28 | 68.03↓3.91 | 67.25↓4.69 |  |
| Semantic-guided | UGS^† (Chen et al., ) | 72.01↑0.93 | 70.29↓1.65 | 68.43↓3.51 | 67.85↓4.09 |
| GEBT (You et al., ) | 70.22↓1.72 | 69.40↓2.54 | 67.84↓4.10 | 67.49↓4.45 |  |
| MGSpar (Wan & Schweitzer, ) | 70.02↓1.92 | 69.34↓2.60 | 68.02↓3.92 | 65.78↓6.16 |  |
| ACE-GLT^† (Wang et al., ) | 72.13↑0.19 | 71.96↑0.02 | 69.13↓2.81 | 67.93↓4.01 |  |
| WD-GLT^† (Hui et al., ) | 71.92↓0.02 | 70.21↓1.73 | 68.30↓3.64 | 66.57↓5.37 |  |
| AdaGLT (Zhang et al., ) | 71.98↑0.04 | 70.44↓1.50 | 69.15↓2.79 | 68.05↓3.89 |  |
| MoG (Ours)^† | 72.08${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.14}}$ | 71.98${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.05}}$ | 69.86↓-2.08 | 68.20${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{-3.74}}$ |  |
| Whole Dataset | 71.93±0.04 |  |  |  |  |

**Table 11: Node classification performance comparison to state-of-the-art sparsification methods. All methods are trained using DeeperGCN, and the reported metrics represent the average of five runs. We denote methods with ${\dagger}$ that do not have precise control over sparsity; their performance is reported around the target sparsity $\pm 2\%$. “OOM” and “OOT” denotes out-of-memory and out-of-time, respectively.**
|  | Dataset | ogbn-proteins (ROC-AUC $\uparrow$) |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Sparsity % | 10 | 30 | 50 | 70 |  |
| Topology-guided | Random | 80.18↓2.55 | 78.92↓3.83 | 76.57↓6.16 | 72.69↓10.04 |
| Rank Degree^† (Voudigari et al., ) | 80.14↓2.59 | 79.05↓3.73 | 78.59↓4.13 | 76.22↓6.51 |  |
| Local Degree^† (Hamann et al., ) | 79.40↓3.33 | 79.83↓3.90 | 78.50↓4.23 | 78.25↓4.48 |  |
| Forest Fire^† (Leskovec et al., ) | 81.49↓1.24 | 78.47↓4.26 | 76.14↓6.59 | 73.89↓9.84 |  |
| G-Spar (Murphy, ) | 81.56↓1.17 | 81.12↓1.61 | 79.13↓3.60 | 77.45↓5.28 |  |
| LSim^† (Satuluri et al., ) | 80.30↓2.43 | 79.19↓3.54 | 77.13↓5.60 | 77.85↓4.88 |  |
| SCAN (Xu et al., ) | 81.60↓1.13 | 80.19↓2.54 | 81.53↓1.20 | 78.58↓4.15 |  |
| ER (Spielman & Srivastava, ) | OOT |  |  |  |  |
| DSpar (Liu et al., ) | 81.46↓1.27 | 80.57↓2.16 | 77.41↓5.32 | 75.35↓7.39 |  |
| Semantic-guided | UGS^† (Chen et al., ) | 82.33↓0.40 | 81.54↓1.19 | 78.75↓4.98 | 76.40↓6.33 |
| GEBT (You et al., ) | 80.74↓2.99 | 80.22↓2.51 | 79.81↓3.92 | 76.05↓6.68 |  |
| MGSpar (Wan & Schweitzer, ) | OOM |  |  |  |  |
| ACE-GLT^† (Wang et al., ) | 82.93↑0.80 | 82.01↓0.72 | 81.05↓1.68 | 75.92↓6.81 |  |
| WD-GLT^† (Hui et al., ) | OOM |  |  |  |  |
| AdaGLT (Zhang et al., ) | 82.60↓0.13 | 82.76↑0.97 | 80.55↓2.18 | 78.42↓4.31 |  |
| MoG (Ours)^† | 83.32${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.41}}$ | 82.14${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{0.59}}$ | 81.92${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{0.81}}$ | 80.90${}_{\color[rgb]{0.15,1,0.67}\definecolor[named]{pgfstrokecolor}{rgb}{<br>0.15,1,0.67}\pgfsys@color@cmyk@stroke{0.85}{0}{0.33}{0}\pgfsys@color@cmyk@fill<br>{0.85}{0}{0.33}{0}\downarrow\textbf{1.83}}$ |  |
| Whole Dataset | 82.73±0.02 |  |  |  |  |

**Table 12: Graph classification performance comparison to state-of-the-art sparsification methods. All methods are trained using PNA, and the reported metrics represent the average of five runs. We denote methods with ${\dagger}$ that do not have precise control over sparsity; their performance is reported around the target sparsity $\pm 2\%$.**
|  | Dataset | cifar-10 (Accuracy $\uparrow$) |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Sparsity % | 10 | 30 | 50 | 70 |  |
| Topology | Random | 68.04↓1.70 | 66.81↓2.93 | 65.35↓4.39 | 62.14↓7.60 |
| Rank Degree^† (Voudigari et al., ) | 68.27↓1.77 | 67.14↓2.60 | 64.05↓5.69 | 60.22↓9.52 |  |
| Local Degree^† (Hamann et al., ) | 68.10↓1.64 | 67.29↓2.45 | 64.96↓4.78 | 61.77↓8.97 |  |
| G-Spar (Murphy, ) | 67.13↓2.61 | 65.06↓4.68 | 64.86↓4.88 | 62.92↓6.82 |  |
| LSim^† (Satuluri et al., ) | 69.75↑0.01 | 67.33↓2.41 | 66.58↓3.16 | 64.86↓4.88 |  |
| SCAN (Xu et al., ) | 68.25↓1.49 | 66.11↓3.63 | 64.59↓5.15 | 63.20↓6.54 |  |
| DSpar (Liu et al., ) | 68.94↑0.53 | 66.80↓2.94 | 64.87↓4.87 | 64.10↓5.64 |  |
| Sema | AdaGLT (Zhang et al., ) | 69.77↑0.02 | 67.97↓1.78 | 65.06↓4.68 | 64.22↓5.52 |
| MoG (Ours)^† | 70.04${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{0.30}}$ | 69.80${}_{\color[rgb]{1,0.23,0.13}\definecolor[named]{pgfstrokecolor}{rgb}{<br>1,0.23,0.13}\pgfsys@color@cmyk@stroke{0}{0.77}{0.87}{0}\pgfsys@color@cmyk@fill<br>{0}{0.77}{0.87}{0}\uparrow\textbf{-0.94}}$ | 68.28↓-1.46 | 66.55↓-3.19 |  |
| Whole Dataset | 69.74±0.17 |  |  |  |  |

### G.2 Sensitivity analysis of parameter k

Based on the experiments in Section 4.4, we further provide sensitivity analysis results on ogbn-proteins+RevGNN, as shown in Table 13. It can be observed that MoG achieves peak performance at $k\in\{2,3\}$ and begins to decline after $k\geq 4$, which is consistent with our finding in Observation 6.

**Table 13: Sensitivity analysis of parameter $k$ when applying MoG to ogbn-proteins+RevGNN.**
| $k$ | 1 | 2 | 3 | 4 | 5 |
| --- | --- | --- | --- | --- | --- |
| MoG | 88.37 | 89.04 | 89.09 | 88.55 | 88.20 |

We also reported the impact of selecting different values of $k$ on the per-epoch training time and inference time, when applyng MoG to ogbn-arxiv+GraphSAGE in Table 14. It can be observed that although the training and inference cost of MoG increases as the number of selected experts increases, this additional cost is not significant: when $k$ doubles from 2 to 4, the inference time only increases by 23%. More importantly, we can already achieve optimal performance with $k\in\{2,3\}$, so there is no need to select too many experts, therefore avoiding significant inference delay.

**Table 14: Sensitivity analysis of parameter $k$ when applying MoG to ogbn-arxiv+GraphSAGE.**
| Sparsity | Selected Expert $k$ | Per-Epoch Time | Inference Time | Acc. |
| --- | --- | --- | --- | --- |
| 30% | 2 | 0.213 | 0.140 | 70.53 |
| 30% | 3 | 0.241 | 0.161 | 70.48 |
| 30% | 4 | 0.266 | 0.173 | 70.13 |
| 30% | 5 | 0.279 | 0.190 | 69.57 |

### G.3 Ablation study on the noise control of the router networ

**Table 15: Ablation study on the noise control of the router network $\Psi$. $\epsilon\sim\mathcal{N}(0,\mathbf{I})$ corresponds to the original setting in our paper, $\epsilon=0$ corresponds to completely remove the noise modeling, and $\epsilon=0.2$ corresponds to fixing the noise coefficient.**
| Sparsity | Train Acc | Valid Acc | Test Acc | $k$ |
| --- | --- | --- | --- | --- |
| $\epsilon\sim\mathcal{N}(0,\mathbf{I})$ |  |  |  |  |
| 10% | 77.20 | 72.68 | 71.93 | 3 |
| 30% | 76.03 | 71.90 | 70.53 | 3 |
| 50% | 72.45 | 69.54 | 69.06 | 3 |
| $\epsilon=0$ |  |  |  |  |
| 10% | 76.87 | 72.05 | 71.27 | 3 |
| 30% | 75.99 | 71.15 | 70.14 | 3 |
| 50% | 72.09 | 68.34 | 67.05 | 3 |
| $\epsilon=0.2$ |  |  |  |  |
| 10% | 76.98 | 72.22 | 71.75 | 3 |
| 30% | 75.98 | 71.48 | 70.27 | 3 |
| 50% | 73.15 | 69.84 | 68.45 | 3 |

We test three different settings of epsilon on GraphSAGE+Ogbn-Arxiv: (1) $\epsilon\sim\mathcal{N}(0,\mathbf{I})$, (2) $\epsilon=0$, and (3) $\epsilon=0.2$, and report their performance under different sparsity levels in Table 15. We can see that trainable noisy parameters always bring the greatest performance gain to the model, which is consistent with previous practices in MoE that the randomness in the gating network is beneficial.

## Appendix H Broader Impact

MoG, as a novel concept in graph sparsification, holds vast potential for general application. It allows for the sparsification of each node based on its specific circumstances, making it well-suited to meet the demands of complex real-world scenarios such as financial fraud detection and online recommender systems, which require customized approaches. More importantly, MoG provides a selectable pool for future sparsification, enabling various pruning algorithms to collaborate and enhance the representational capabilities of graphs.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: Please refer to the weaknesses above.
soundness: 3
strengths: 1. The experiments show the MoG's adaptability across different graph learning tasks. They also show MoG’s ability to improve inference speed while maintaining or even boosting accuracy (up to 1.74% in some cases) demonstrates its practical benefits. 
2. The paper introduces a novel method, Mixture-of-Graphs (MoG), which applies the Mixture-of-Experts (MoE) concept to graph sparsification. Unlike traditional sparsification methods with uniform criteria, MoG combines sparsity levels and pruning criterias to each node’s local context.
3. The paper clearly defines the MoG framework, including the sparsifier expert selection process, node-wise routing, and mixture on the Grassmann manifold. The mathematical framework is well-detailed, particularly in describing the sparsifier expert selection via the noisy top-k gating mechanism and the Grassmann manifold’s role in mixing sparse subgraphs.
4. MoG's ability to achieve significant sparsity without a substantial performance drop highlights its potential to improve GNN deployment in resource-limited environments. By effectively balancing computational efficiency and accuracy, MoG could effectively serve as a plugin to boost GNN performance, from real-time social network analysis to large-scale molecular data processing.
summary: This paper presents a novel graph sparsification method, Mixture-of-Graphs (MoG), to optimize Graph Neural Networks (GNNs) for large-scale graphs. MoG dynamically selects node-specific sparsification levels and criteria, improving computational efficiency and performance.
Inspired by the Mixture-of-Experts framework, MoG employs multiple sparsifier experts, each with distinct sparsity settings and pruning criteria. This approach customizes edge pruning for each node, addressing limitations of previous global sparsification techniques.
MoG assembles sparse subgraphs on the Grassmann manifold, enhancing graph structure while preserving node connectivity. Extensive experiments across diverse datasets demonstrate MoG’s ability to achieve significant sparsity with minimal performance loss.
The authors validate MoG’s effectiveness through experiments on large-scale datasets. MoG achieves faster GNN inference and better performance in some cases. MoG’s flexible sparsification method shows potential for advancing GNN deployment in resource-limited environments.

-----------------------------------
After reading all the responses and the improved manuscript, I think this paper can be considered to be accepted. Thus, I raised my rating to 'accept', because there is no '7'.
weaknesses: 1. The paper does not clarify in “4 EXPERIMENTS” or “Appendix F.6” why the specific 12 combinations of sparsity levels and criteria were selected. Additionally, the variance of each row across combinations in Table 8 is minimal, raising questions about the distinctiveness of each sparsifier.
Furthermore, in “Appendix F.6”, different sparsity criteria are applied in different datasets without an explanation of the selection rationale.
To enhance experimental completeness, the authors might consider exploring a wider range of sparsity combinations with greater variance. Additionally, providing the reasoning behind dataset-specific combinations would help readers understand the adaptability of MoG across different graph structures.

2. The process of integrating sparse subgraphs on the Grassmann manifold, as outlined in Section 3.4, is mathematically dense and lacks intuitive explanation. While the theoretical basis is strong, the connection between the Grassmann manifold’s properties and its benefits for graph sparsification may not be immediately clear to all readers.

3. The terminology for sparsifiers and experts appears inconsistent across sections, which could lead to confusion. For instance, “sparsifier experts” and “experts” are used interchangeably.

Minor Comment:
4. In Section 2, there is a spelling error in the title “TECHNICAL BACKGOUND,” which should be “TECHNICAL BACKGROUND.” I recommend reviewing the document to ensure there are no similar spelling errors throughout.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: Please check weakness 1.
soundness: 3
strengths: 1. The proposed method has a certain degree of innovation, especially in the use of MoE and the approach to combining graphs.
2. The proposed method can be integrated with any framework.
3. The paper includes extensive experiments.
summary: This paper proposes a method called **MoG**, which uses the technique of MoE to integrate multiple ego-net sparsifier strategies in GNNs. 

First, for each ego-net, the authors introduce a simple noisy top-k gating mechanism as a routing module to select K sparsifier experts, each with different sparsity levels and sparsification strategies. 

Then, using Grassmann manifold techniques, the authors combine these sparsified ego graphs, with objective function Eq.11 and its closed-form solution in Eq.12.

The experiments show that compared to other sparsification methods:
- In terms of accuracy, MoG has a slight advantage in two node classification datasets and a more noticeable effect in two graph classification datasets.
- In terms of balancing inference speed and accuracy, MoG achieves higher accuracy when reaching the same speedup.

The authors also conducted additional experiments, such as sensitivity analysis.
weaknesses: 1. Eq.11 is a core objective, but it is quite heuristic. Moreover, after obtaining the combined graph with Eq.12, there is a post-sparsification operation. Does the final ensembled sparse Laplacian truly integrate the eigenvectors of multiple sparsified ego-net Laplacians as the authors hope? Regardless of the degree achieved, it would be helpful to see experimental evidence here.

2. There are only two node classification and two graph classification datasets, which is relatively few.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: A couple of questions on output:

1. In figure 1 (Middle), we attribute edge pruning to different sparsifiers. Did we perform this qualitative analysis on an actual sparsified graph, or is it an imagined example to represent our hypothesis? Although not required to perform this if not done already, I was simply wondering if it was the case and was interested in knowing more about it.
2. What is the difference between observed average sparsity just after ensembling in eq. 13 and after the post-sparsification step of eq. 14? Curious to understand how much more the graph density changes after the optimization in eq 11.
soundness: 3
strengths: 1. Tackles a topical and highly relevant problem in graph learning on large graphs.
2. Highly flexible, well-motivated approach that accounts for local node variations while determining optimal pruning strategy.
3. Ample experiments across baselines and datasets, replete with sensitivity analysis, ablation studies, and efficiency comparison.
summary: The authors propose a mixture-of-graphs (MoG) approach inspired by mixture-of-experts for graph sparsification. Instead of having global/uniform pruning criteria, they create a dynamic strategy tailored to each node’s neighborhood. This is done by utilizing each node’s egograph to select a few sparsifiers (experts) from a larger pool. The outputs of selected sparsifiers are ensembled using Grassmann manifold theory to generate a single sparsified ego graph per node and are later re-combined to form the final graph. Their approach outperforms baselines across several datasets, maintaining performance at higher sparsity levels and sometimes even improving it due to reduction of noise after sparsification.
weaknesses: Adding below-mentioned minor clarifications around methodology may be useful:

1. How are post-sparsified ego-graphs assembled? Is it possible that for two nodes $i$ and $j$, the post-sparsified ego graph of $i$ connects to $j$ but the post-sparsified ego graph of $j$ doesn’t connect to $i$? If yes, how is this handled?
2. How do we select $p$ in equation 10? What is its impact on performance?
3. What does $D$ in eq. 13 correspond to? Is it from the original ego graph of the given node? If yes, why do we use the same $D$? Would it not introduce some approximation error since it doesn’t correspond exactly to the learned laplacian?
4. The method seems entirely local. For some downstream tasks, it may be relevant to take the global graph structure into consideration, for example, to ensure the graph stays connected. How does the proposed approach tackle this?

---

confidence: 2
contribution: 2
initial_rating: 6
presentation: 4
questions: **Significance**

Is there a real use case the authors can point to where SpMM compute limits people who are using/want to use GNNs? In my opinion, the significance of this type of ML research is measured by the significance of the problem it is solving/the capability it unlocks. Otherwise this is a more of a neat contribution to the literature which we simply speculate to be useful eventually.

&nbsp;

**The use of Gaussian Noise in the MoE step**

Perhaps I show my naivety re: MoE, but why do we believe added \epsilon \sim N(0,1) noise is of a suitable scale to effectively alter the routing? Is there a particular normalization of activations to ensure \epsilon interacts with numbers of this scale?
soundness: 4
strengths: I thought the writing was clear for the most part, with the exception being the contributions/intro (see Weaknesses). The figures are excellent. I haven't seen prior work on MoE re: sparsity, so I believe it to be original, although not very confident. 

&nbsp;

This work could be significant. Indeed, GNN inference cost has motivated much GNN research in the past; see Questions for more of my thoughts on this.
summary: This work leverages the Mixture-of-Experts (MoE) approach, a well-established technique in deep learning domains such as language modeling, to scale model capacity (i.e., the number of parameters) while managing computational demands. In this context, the MoE concept is applied dynamically and locally sparsity to the underlying graph during GNN inference. The authors demonstrate that this method maintains performance while reducing inference time.
weaknesses: **Making Contributions Clear**

I suggest making more clear the contributions of the paper and what the authors are claiming novelty on. Many papers use bullet points at the end of the introduction section to denote this; this work has bullet points near the end of the introduction, but they do not correspond to contributions, making the reading a bit confusing for regular readers of ICLR proceedings.

&nbsp;

**Some Missing Background in Graph Sparsification**

There is extensive literature on graph sparsification coming from the statistics and optimization world, commonly referred to under the umbrella term ‘Graph Structure Learning’. Most of these approaches indeed use some global sparsity promoting criteria; you could state how your approach has advantages over this more coarse approach. I include references to a classical work and a recent work. The latter has an overview of recent Graph Structure Learning approaches, most of which indeed use some global sparsity criterion in their objective.

&nbsp;

Friedman, Jerome, Trevor Hastie, and Robert Tibshirani. "Sparse inverse covariance estimation with the graphical lasso." Biostatistics 9.3 (2008): 432-441.

Wasserman, Max, and Gonzalo Mateos. "Graph Structure Learning with Interpretable Bayesian Neural Networks." Transactions on machine learning research (2024).

&nbsp;

**Missing Experiment/Ablation Study**

A simple baseline I expect to see would be to somehow prune the graph to a particular sparsity level and run a GNN on that. Perhaps some sort of edge sampling procedure selects a subset of edges to prune such that the global sparsity is set to ~=x, perhaps preferring edges to remove in proportional to the adjacent nodes' degree, while ensuring no disconnected nodes. Do so for a few sparsity levels. This would provide a good idea for how much benefit is really to be gotten from this whole effort, beyond the straightforward pruning approach.

Perhaps this ablation study is done implicitly in one of the baselines. Please correct me if so.

Meta-review: In this submission, the authors leverage the idea of the mixture of graphs (MoG) to achieve adaptive graph sparsification. Applying MoG to GNNs can reduce the computational costs significantly while maintaining high performance on large-scale graph learning tasks. The idea of MoG is simple but effective, which works for various tasks and datasets. In the revised paper and the rebuttal, the authors provide sufficient experiments and detailed analytic content to verify the rationality and feasibility of the proposed method.

Decision: Accept (Spotlight)