A Unified Lottery Ticket Hypothesis for Graph Neural Networks

Introduction

Graph Neural Networks (GNNs) (Zhou et al., 2018; Kipf & Welling, 2016; Chen et al., 2019; Veličković et al., 2017) have established state-of-the-art results on various graph-based learning tasks, such as node or link classification (Kipf & Welling, 2016; Veličković et al., 2017; Qu et al., 2019; Verma et al., 2019; Karimi et al., 2019; You et al., 2020d, c), link prediction (Zhang & Chen, 2018), and graph classification (Ying et al., 2018; Xu et al., 2018; You et al., 2020b). GNNs’ superior performance results from the structure-aware exploitation of graphs. To update the feature of each node, GNNs first aggregate features from neighbor connected nodes, and then transform the aggregated embeddings via (hierarchical) feed-forward propagation.

However, the training and inference of GNNs suffer from the notorious inefficiency, and pose hurdle to GNNs from being scaled up to real-world large-scale graph applications. This hurdle arises from both algorithm and hardware levels. On the algorithm level, GNN models can be thought of a composition of traditional graphs equipped with deep neural network (DNN) algorithms on vertex features. The execution of GNN inference falls into three distinct categories with unique computational characteristics: graph traversal, DNN computation, and aggregation. Especially, GNNs broadly follow a recursive neighborhood aggregation (or message passing) scheme, where each node aggregates feature vectors of its multi-hop neighbors to compute its new feature vector. The aggregation phase costs massive computation when the graphs are large and with dense/complicated neighbor connections (Xu et al., 2018). On the hardware level, GNN’s computational structure depends on the often sparse and irregular structure of the graph adjacency matrices. This results in many random memory accesses and limited data reuse, but also requires relatively little computation. As a result, GNNs have much higher inference latency than other neural networks, limiting them to applications where inference can be pre-computed offline (Geng et al., 2020; Yan et al., 2020).

This paper aims at aggressively trimming down the explosive GNN complexity, from the algorithm level. There are two streams of works: simplifying the graph, or simplifying the model. For the first stream, many have explored various sampling-based strategies (Hübler et al., 2008; Chakeri et al., 2016; Calandriello et al., 2018; Adhikari et al., 2017; Leskovec & Faloutsos, 2006; Voudigari et al., 2016; Eden et al., 2018; Zhao, 2015; Chen et al., 2018a), often combined with mini-batch training algorithms for locally aggregating and updating features. Zheng et al. (2020) investigated graph sparsification, i.e., pruning input graph edges, and learned an extra DNN surrogate. Li et al. (2020b) also addressed graph sparsification by formulating an optimization objective, solved by alternating direction method of multipliers (ADMM) (Bertsekas & Rheinboldt, 1982).

The second stream of efforts were traditionally scarce, since the DNN parts of most GNNs are (comparably) lightly parameterized, despite the recent emergence of increasingly deep GNNs (Li et al., 2019). Although model compression is well studied for other types of DNNs (Cheng et al., 2017), it has not been discussed much for GNNs. One latest work (Tailor et al., 2021) explored the viability of training quantized GNNs, enabling the usage of low precision integer arithmetic during inference. Other forms of well-versed DNN compression techniques, such as model pruning (Han et al., 2016), have not been exploited for GNNs up to our best knowledge. More importantly, no prior discussion was placed on jointly simplifying the input graphs and the models for GNN inference. In view of such, this paper asks: to what extent could we co-simplify the input graph and the model, for ultra-efficient GNN inference?

This paper makes multi-fold contributions to answer the above questions. Unlike pruning convolutional DNNs which are heavily overparameterized, directly pruning the much less parameterized GNN model would have only limited room to gain. Our first technical innovation is to for the first time present an end-to-end optimization framework called unified GNN sparsification (UGS) that simultaneously prunes the graph adjacency matrix and the model weights. UGS makes no assumption to any GNN architecture or graph structure, and can be flexibly applied across various graph-based learning scenarios at scale.

Considering UGS as the generalized pruning for GNNs, our second technical innovation is to generalize the popular lottery ticket hypothesis (LTH) to GNNs for the first time. LTH (Frankle & Carbin, 2018) demonstrates that one can identify highly sparse and independently trainable subnetworks from dense models, by iterative pruning. It was initially observed in convolutional DNNs, and later broadly found in natural language processing (NLP) (Chen et al., 2020b), generative models (Kalibhat et al., 2020), reinforcement learning (Yu et al., 2020) and lifelong learning (Chen et al., 2020b). To meaningfully generalize LTH to GNNs, we define a graph lottery ticket (GLT) as a pair of core sub-dataset and sparse sub-network which can be jointly identified from the full graph and the original GNN model, by iteratively applying UGS. Like its counterpart in convolutional DNNs, a GLT could be trained from its initialization to match the performance of training with the full model and graph, and its inference cost is drastically smaller.

Our proposal has been experimentally verified, across various GNN architectures and diverse tasks, on both small-scale graph datasets (Cora, Citeseer and PubMed), and large-scale datasets from the challenging Open Graph Benchmark (OGB). Our main observations are outlined below:

UGS is widely applicable to simplifying a GNN during training and reducing its inference MACs (multiply–accumulate operations). Moreover, by iteratively applying UGS, GLTs can be broadly located from for both shallow and deep GNN models, on both small- and large-scale graph datasets, with substantially reduced inference costs and unimpaired generalization.

For node classification, our found GLTs achieve $20\%\sim 98\%$ MACs saving, with up to $5\%\sim 58.19\%$ sparsity on graphs and $20\%\sim 97.75\%$ sparsity on GNN models, at little to no performance degradation. For example in Figure 1, on Cora and Citeseer node classification, our GLTs (★) achieve comparable or sometimes even slightly better performance than the baselines of full models and graphs ({\color[rgb]{0,0,0}\bullet}), with only $41.16\%$ and $5.57\%$ MACs, respectively.

For link prediction, GLTs lead to $48\%\sim 97\%$ and $70\%$ MACs saving, coming from up to $22.62\%\sim 55.99\%$ sparsity on graphs and and $67.23\%\sim 97.19\%$ sparsity on GNN models, again without performance loss.

Our proposed framework can scale up to deep GNN models (up to $28$ layers) on large graphs (e.g., Ogbn-ArXiv and Ogbn-Proteins), without bells and whistles.

Besides from random initializations, GLTs can also be drawn from the initialization via self-supervised pre-training – an intriguing phenomenon recently just reported for NLP (Chen et al., 2020b) and computer vision models (Chen et al., 2020a). Using a latest GNN pre-training algorithm (You et al., 2020b) for initialization, GLTs can be found to achieve robust performance with even sparser graphs and GNNs.

Related Work

There are mainly three categories of GNNs (Dwivedi et al., 2020): i) extending original convolutional neural networks to the graph regime (Scarselli et al., 2008; Bruna et al., 2013; Kipf & Welling, 2016; Hamilton et al., 2017); ii) introducing anisotropic operations on graphs such as gating and attention (Battaglia et al., 2016; Monti et al., 2017; Veličković et al., 2018), and iii) improving upon limitations of existing models (Xu et al., 2019; Morris et al., 2019; Chen et al., 2019; Murphy et al., 2019). Among this huge family, Graph Convolutional Networks (GCNs) are widely adopted, which can be categorized as spectral domain based methods (Defferrard et al., 2016; Kipf & Welling, 2016) and spatial domain bases methods (Simonovsky & Komodakis, 2017; Hamilton et al., 2017).

The computational cost and memory usage of GNNs will expeditiously increase with the graph size. The aim of graph sampling or sparsification is to extract a small sub-graph from the original large one, which can remain effective for learning tasks (Zheng et al., 2020; Hamilton et al., 2017) while reducing the cost. Previous works on sampling focus on preserving certain pre-defined graph metrics (Hübler et al., 2008), graph spectrum (Chakeri et al., 2016; Adhikari et al., 2017), or node distribution (Leskovec & Faloutsos, 2006; Voudigari et al., 2016; Eden et al., 2018). FastGCN (Chen et al., 2018a) introduced a global importance sampling method instead of locally neighbor sampling. VRGCN (Chen et al., 2018b) proposed a control variate based algorithm, but requires all intermediate vertex embeddings to be saved during training. Cluster-GCN (Chiang et al., 2019) used clustering to partition subgraphs for training, but often suffers in stability. Zheng et al. (2020); Li et al. (2020b) cast graph sparsification as optimization problems, solved by learning surrogates and ADMM, respectively.

Lottery Ticket Hypothesis (LTH).

Since the original LTH (Frankle & Carbin, 2018), a lot of works have explored the prospect of trainable sparse subnetworks in place of the full models without sacrificing performance. Frankle et al. (2019); Renda et al. (2020) introduced the rewinding techniques to scale up LTH. LTH was also adopted in different fields (Evci et al., 2019; Savarese et al., 2020; Liu et al., 2019; You et al., 2020a; Gale et al., 2019; Yu et al., 2020; Kalibhat et al., 2020; Chen et al., 2021b, 2020b, 2020c, a; Ma et al., 2021; Gan et al., 2021).

However, GNN is NOT “yet another” field that can be easily cracked by LTH. That is again due to GNNs having much smaller models, while all the aforementioned LTH works focus on simplifying their redundant models. To our best knowledge, this work is not only the first to generalize LTH to GNNs, but also the first to extend LTH from simplifying models to a new data-model co-simplification prospect.

Methodology

2 Unified GNN Sparsification

We present out end-to-end framework, Unified GNN Sparsification (UGS), to simultaneously reduce edges in $\mathcal{G}$ and the parameters in GNNs. Specifically, we introduce two differentiable masks $\bm{m}_{g}$ and $\bm{m}_{\theta}$ for indicating the insignificant connections and weights in the graph and GNNs, respectively. The shapes of $\bm{m}_{g}$ and $\bm{m}_{\theta}$ are identical to those the adjacency matrix $\bm{A}$ and the weights $\bm{\Theta}$, respectively. Given $\bm{A}$, $\bm{\Theta}$, $\bm{m}_{g}$ and $\bm{m}_{\theta}$ are co-optimized from end to end, under the following objective:

3 Graph Lottery Tickets

Given a GNN $f(\cdot,\bm{\Theta})$ and a graph $\mathcal{G}=\{\bm{A},\bm{X}\}$, the associated subnetworks of GNN and sub-graph can be defined as $f(\cdot,\bm{m}_{\theta}\odot\bm{\Theta})$ and $\mathcal{G}_{s}=\{\bm{m}_{g}\odot\bm{A},\bm{X}\}$, where $\bm{m}_{g}$ and $\bm{m}_{\theta}$ are binary masks defined in Section 3.2. If a subnetwork $f(\cdot,\bm{m}_{\theta}\odot\bm{\Theta})$ trained on a sparse graph $\mathcal{G}_{s}$ has performance matching or surpassing the original GNN trained on the full graph $\mathcal{G}$ in terms of achieved standard testing accuracy, then we define $f(\{\bm{m}_{g}\odot\bm{A},\bm{X}\},\bm{m}_{\theta}\odot\bm{\Theta}_{0})$ as a unified graph lottery tickets (GLTs), where $\bm{\Theta}_{0}$ is the original initialization for GNNs which the found lottery ticket subnetwork is usually trained from.

Unlike previous LTH literature (Frankle & Carbin, 2018), our identified GLT will consist of three elements: i) a sparse graph $\mathcal{G}_{s}=\{\bm{m}_{g}\odot\bm{A},\bm{X}\}$; ii) the sparse mask $\bm{m}_{\theta}$ for the model weight; and iii) the model weight’s initialization $\bm{\Theta_{0}}$.

Finding GLT.

Classical LTH leverages iterative magnitude-based pruning (IMP) to identify lottery tickets. In a similar fashion, we apply our UGS algorithm to prune both the model and the graph during training, as outlined Algorithm 2, obtaining the graph mask $\bm{m}_{g}$ and model weight mask $\bm{m}_{\theta}$ of GLT. Then, the GNN weights are rewound to the original initialization $\bm{\Theta}$. We repeat the above two steps iteratively, until reaching the desired sparsity $s_{g}$ and $s_{\theta}$ for the graph and GNN, respectively.

Complexity analysis of GLTs.

Experiments

In this section, extensive experiments are reported to validate the effectiveness of UGS and the existence of GLTs across diverse graphs and GNN models. Our subjects include small- and medium-scale graphs with two-layer Graph Convolutional Network (GCN) (Kipf & Welling, 2016), Graph Isomorphism Network (GIN) (Xu et al., 2018), and Graph Attention Network (GAT) (Veličković et al., 2017) in Section 4.2; as well as large-scale graphs with 28-layer deep ResGCNs (Li et al., 2020a) in Section 4.2. Besides, in Section 4.3, we investigate GLTs under the self-supervised pre-training (You et al., 2020b). Ablation studies and visualizations are provided in Section 4.4 and 4.5.

We use popular semi-supervised graph datasets: Cora, Citeseer and PubMed (Kipf & Welling, 2016), for both node classification and link prediction tasks. For experiments on large-scale graphs, we use the Open Graph Benchmark (OGB) (Hu et al., 2020), such as Ogbn-ArXiv, Ogbn-Proteins, and Ogbl-Collab. More datasets statistics are summarized in Table 1. Other details such as the datasets’ train-val-test splits are included in Appendix A1.

Training and Inference Details

Our evaluation metrics are shown in Table 1, following Kipf & Welling (2016); Hu et al. (2020); Mavromatis & Karypis (2020). More detailed configurations such as learning rate, training iterations, and hyperparameters in UGS, are referred to Appendix A1.

1 The Existence of Graph Lottery Ticket

We first examine whether unified graph lottery tickets exist and can be located by UGS. Results of GCN/GIN/GAT on Cora/Citesser/PubMed for node classification and link prediction are collected in Figures 3 and 4, respectively. Note that each point in the figures denotes the achieved performance with respect to a certain graph sparsity, GNN sparsity, and inference MACs. However, due to the limited space, we only include one or two of these three sparsity indicators in the main text, and the rest can be found in Appendix A2. We list the following Observations.

Graph lottery tickets at a range of graph sparsity from $5\%$ to $58.19\%$ without performance deterioration, can be identified across GCN, GIN and GAT on Cora, Citeseer, and PubMed datasets for both node classification and link prediction tasks. Such GLTs significantly reduce $59\%\sim 97\%$, $20\%\sim 98\%$, $91\%\sim 97\%$ inference MACs for GCN, GIN and GAT across all datasets.

Obs.2. UGS is flexible and consistently shows superior performance.

UGS consistently surpasses random pruning by substantial performance margins across all datasets and GNNs, which validates the effectiveness of our proposal. The previous state-of-the-art method, i.e., ADMM (Li et al., 2020b), achieves a competitive performance to UGS at moderate graph sparsity levels, and performs $3\sim 4\%$ worse than UGS when graphs are heavily pruned.

Note that the ADMM approach by Li et al. (2020b) is only applicable when two conditions are met: i) graphs are stored via adjacency matrices—however, that is not practical for large graphs (Hu et al., 2020); ii) aggregating features with respect to adjacency matrices—however, recent designs of GNNs (e.g., GIN and GAT) commonly use the much more computation efficient approach of synchronous/asynchronous message passing (Gilmer et al., 2017; Busch et al., 2020). On the contrary, our proposed UGS is flexible enough and free of these limitations.

As demonstrated in Figures 3 and 4, compared to GCN and GIN, GLTs in GAT can be found at higher sparsity levels; meanwhile randomly pruned graphs and GAT can still reach satisfied performance and maintain higher accuracies on severely sparsified graphs.

One possible explanation is that attention-based aggregation is capable of re-identifying important connections in pruned graphs which makes GAT be more amenable to sparsification. Compared the sparsity of located GLTs (i.e., the position of red stars (★)) across three graph datasets, we find that Cora is the most sensitive graph to pruning and PubMed is more robust to be sparsified.

2 Scale Up Graph Lottery Tickets

To scale up graph lottery tickets, we further conduct experiments on 28-layer deep ResGCNs (Li et al., 2020a) on large-scale datasets that have more than millions of connections, like Ogbn-ArXiv and Ogbn-Proteins for node classification, Ogbl-Collab for link prediction in Table 1. We summarize our observations and derive insights below.

Figure 5 demonstrates that UGS can be scaled up to deep GCNs on large-scale graphs. Found GLTs obtain matched performance with $85\%$, $25\%$, $70\%$ MACs saving on Ogbn-ArXiv, Ogbn-Proteins, and Ogbl-Collab, respectively.

Obs.5. Denser graphs (e.g., Ogbn-Proteins) are more resilient to sparsification.

As shown in Figure 5, comparing the node classification results on Ogbn-ArXiv (Ave. degree: 13.77) and Ogbn-Proteins (Ave. degree: 597.00), Ogbn-Proteins has a negligible performance gap between UGS and random pruning, even on heavily pruned graphs. Since nodes with high degrees in denser graphs have less chance to be totally isolated during pruning, it may contribute to more robustness to sparsification. Similar observations can be drawn from the comparison between PubMed and other two small graphs in Figure 3 and 4.

3 Graph Lottery Ticket from Pre-training

High-quality lottery tickets can be drawn from self-supervised pre-trained models, as recently found in both NLP and computer vision fields (Chen et al., 2020b, a). In the GLT case, we also assess the impact of replacing random initialization with self-supervised graph pre-training, i.e., GraphCL (You et al., 2020b), on transductive semi-supervised node classification and link prediction.

From Figure 6 and A12, we gain a few interesting observations. First, UGS with the GraphCL pre-trained initialization consistently presents superior performance at moderate sparsity levels ($\leq 40\%$ graph sparsity $\simeq$ $\leq 85\%$ MACs saving). While the two settings perform similar at extreme sparsity, it indicates that for excessively pruned graphs, the initialization is no longer the performance bottleneck; Second, GraphCL benefits GLT on multiple downstream tasks including node classification and link prediction; Third, especially on the transductive semi-supervised setup, GLTs with appropriate sparsity levels can even enlarge the performance gain from pre-training, for example, see GLT on Citeseer with $22.62\%$ graph sparsity and $2068$M inference MACs.

4 Ablation Study

We extensively investigate the pruning ratios $p_{g}$, $p_{\theta}$ in UGS for graph and GNN sparsification. As shown in Figure 7, with a fixed $p_{\theta}=20\%$, only the setting of $p_{g}=5\%$ can identify the GLT, and it performs close to $p_{g}=10\%$ at higher sparsity levels (e.g., $\geq 25\%$). Aggressively pruning the graph’s connections in each round of iterative UGS, e.g., $p_{g}=20\%$, leads to substantially degraded accuracies, especially for large sparsities. On the other hand, with a fixed $p_{g}=20\%$, all there settings of $p_{\theta}=10\%,20\%,40\%$ show similar performance, and even higher pruning ratios produce slight better results. It again verifies that the key bottleneck in pruning GNNs mainly lies in the sparsification of graphs. In summary, we adopt $p_{g}=5\%$ and $p_{g}=20\%$ (follow previous LTH works (Frankle & Carbin, 2018)) for all the experiments.

Random graph lottery tickets.

Randomly re-initializing located sparse models, i.e., random lottery tickets, usually serves as a necessary baseline for validating the effectiveness of rewinding processes (Frankle & Carbin, 2018). In Table 2, we compare GLT to Random GLT, the latter by randomly re-initializing GNN’s weights and learnable masks, and GLT shows aapparently superior performance, consistent with previous observations (Frankle & Carbin, 2018).

5 Visualization and Analysis

In this section, we visualize the sparsified graphs in GLTs from UGS in Figure 8, and further measure the graph propertiesNetworkX ( https://networkx.org) is used for our analyses. shown in Table A5, including clustering coefficient (Luce & Perry, 1949), as well as node and edge betweenness centrality (Freeman, 1977). Specifically, clustering coefficient measures the proportion of edges between the nodes within a given node’s neighborhood; node and edge betweenness centrality show the degree of central a vertex or an edge is in the graph (Narayanan, 2005). Reported numbers in Table A5 are averaged over all the nodes.

Both Figure 8 and Table A5 show that sparse graphs obtained from UGS seem to maintain more “critical” vertices which used to have much denser connections. It may provide possible insights on what GLTs prefer to preserve.

Conclusion and Discussion

In this paper, we first propose unified GNN sparsification to generalize the notion or pruning in GNNs. We further establish the LTH for GNNs, by leveraging UGS and considering a novel joint data-model lottery ticekt. The new unified LTH for GNNs generalizes across various GNN architectures, learning tasks, datasets, and even initialization ways. In general, we find GLT to tremendously trim down the inference MACs, without sacrificing task performance.

It remains open how much we could translate GLT’s high sparsity into practical acceleration and energy-saving benefits. Most DNN accelerators are optimized for dense and regular computation, making edge-based operations hard to implement efficiently. To our best knowledge, the hardware acceleration research on GNNs just starts to gain interests (Auten et al., 2020; Abadal et al., 2020; Geng et al., 2020; Wang et al., 2020; Kiningham et al., 2020). We expect GLT to be implemented using sparse-dense matrix multiplication (SpMM) operations from highly optimized sparse matrix libraries, such as Intel MKL (Wang et al., 2014) or cuSPARSE (Naumov et al., 2010).

References

Appendix A1 More Implementation Details

As for small-scale datasets, we take the commonly used semi-supervised node classification graphs: Cora, Citeseer and pubMed. For larger-scale datasets, we use three Open Graph Benchmark (OGB) (Hu et al., 2020) datasets: Ogbn-ArXiv, Ogbn-Proteins and Ogbl-Collab. All the download links of adopted graph datasets are included in Table A3.

Train-val-test Splitting of Datasets.

As for node classification of small- and medium-scale datasets, we use 140 (Cora), 120 (Citeseer) and 60 (PubMed) labeled data for training, 500 nodes for validation and 1000 nodes for testing. As for link prediction task of small- and medium-scale datasets Cora, Citeseer and PubMed, we random sample $10\%$ edges as our testing set, $5\%$ for validation, and the rest $85\%$ edges are training set. The training/validation/test splits for Ogbn-ArXiv, Ogbn-Proteins and Ogbl-Collab are given by the benchmark (Hu et al., 2020). Specifically, as for Ogbn-ArXiv, we train on the papers published until 2017, validation on those published in 2018 and test on those published since 2019. As for Ogbn-Proteins, we split the proteins nodes into training/validation/test sets according to the species which the proteins come from. As for Ogbl-Collab, we use the collaborations until 2017 as training edges, those in 2018 as validation edges, and those in 2019 as test edges.

More Details about GNNs.

As for small- and medium-scale datasets Cora, Citeseer and PubMed, we choose the two-layer GCN/GIN/GAT networks with 512 hidden units to conduct all our experiments. As for large-scale datasets Ogbn-ArXiv, Ogbn-Proteins and Ogbl-Collab, we use the ResGCN (Li et al., 2020a) with 28 GCN layers to conduct all our experiments. As for Ogbn-Proteins dataset, we also use the edge encoder module, which is a linear transform function in each GCN layer to encode the edge features. And we found if we also prune the weight of this module together with other weight, it will seriously hurt the performance, so we do not prune them in all of our experiments.

Training Details and Hyper-parameter Configuration.

We conduct numerous experiments with different hyper-parameter, such as iterations, learning rate, $\gamma_{1}$, $\gamma_{2}$, and we choose the best hyper-parameter configuration to report the final results. All the training details and hyper-parameters are summarzed in Table A4. As for Ogbn-Proteins dataset, due to its too large scale, we use the commonly used random sample method (Li et al., 2020a) to train the whole graph. Specifically, we random sample ten subgraphs from the whole graph and we only feed one subgraph to the GCN at each iteration. For each subgraph, we train 10 iterations to ensure better convergence. And we train 100 epochs for the whole graph (100 iterations for each subgraph).

Evaluation Details

We report the test accuracy/ROC-AUC/Hits@50 according to the best validation results during the training process to avoid overfitting. All training and evaluation are conducted for one run. As for the previous state-of-the-art method ADMM (Li et al., 2020b), we use the same training and evaluation setting as the original paper description, and we can reproduce the similar results compared with original paper.

Computing Infrastructures

We use the NVIDIA Tesla V100 (32GB GPU) to conduct all our experiments.

Appendix A2 More Experiment Results

As shown in Figure A9, we also provide extensive results over GNN sparsity of GCN/GIN/GAT on three small datasets, Cora/Citeseer/PubMed. We observe that UGS finds the graph wining tickets at a range of GNNs sparsity from $20\%\sim 90\%$ without performance deterioration, which significantly reduces MACs and the storage memory during both training and inference processes.

A2.2 Link Prediction on Small- and Medium-scale Graphs with shallow GNNs

More results of link prediction with GCN/GIN/GAT on Cora/Citeseer/PubMed datasets are shown in Figure A10. We observe the similar phenomenon as the node classification task: using our proposed UGS can find the graph wining tickets at a range of graph sparsity from $5\%\sim 50\%$ and GNN sparsity from $20\%\sim 90\%$ without performance deterioration, which greatly reduce the computational cost and storage space during both training and inference processes.

A2.3 Large-scale Graphs with Deep ResGCNs

More results of larger-scale graphs with deep ResGCNs are shown in Figure A11. Results show that our proposed UGS can found GLTs, which can reach the non-trivial sparsity levels of graph $30\%\sim 50\%$ and weight $20\%\sim 80\%$ without performance deterioration.

A2.4 Graph Lottery Ticket with Pre-training

More results of node classification and link prediction on Cora and Citeseer dataset of GraphCL (You et al., 2020b) pre-training are shown in Figure A12. Results demonstrate that when using self-supervised pre-training, UGS can identify graph lottery tickets with higher qualities.

A2.5 More Analyses of Sparsified Graphs

As shown in Table A5, graph measurements are reported, including clustering coefficient, node and egde betweeness centrality. Results indicate that UGS seems to produce sparse graphs with more “critical” vertices which used to have more connections.