{'fraction_non_alphanumeric': 0.03491047314194258, 'fraction_numerical': 0.015704711413424027, 'mean_word_length': 4.738125986511695, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Structural Entropy Guided Graph Hierarchical Pooling

Following the success of convolution on non-Euclidean space, the corresponding pooling approaches have also been validated on various tasks regarding graphs. However, because of the fixed compression quota and stepwise pooling design, these hierarchical pooling methods still suffer from local structure damage and suboptimal problem. In this work, inspired by structural entropy, we propose a hierarchical pooling approach, SEP, to tackle the two issues. Specifically, without assigning the layer-specific compression quota, a global optimization algorithm is designed to generate the cluster assignment matrices for pooling at once. Then, we present an illustration of the local structure damage from previous methods in the reconstruction of ring and grid synthetic graphs. In addition to SEP, we further design two classification models, SEP-G and SEP-N for graph classification and node classification, respectively. The results show that SEP outperforms state-of-the-art graph pooling methods on graph classification benchmarks and obtains superior performance on node classifications.


Introduction
Chasing the great success of deep learning in natural language processing and images, plenty of research efforts have been devoted to the adoption of neural networks in tasks without data on the Euclidean domain, i.e., in graphs (Kipf & Welling, 2017;Veličković et al., 2018). Thus, recent years, graph neural networks (GNNs) become ubiquitous within deep learning for graphs, and have obtained great accomplishments in various domains, such as node classification (Kipf & Welling, 2017), link prediction (Zhang & Proceedings of the 39 th International Conference on Machine Learning, Baltimore, Maryland, USA, PMLR 162, 2022. Copyright 2022 by the author(s).  Figure 1: Architecture of proposed SEP operator combined with graph neural network. The graph neural network consists of message passing layers and hierarchical pooling layers. A separate algorithm is proposed for cluster assignments generation.  and graph classification (Xu et al., 2019). In these works, a key direction is the convolutional mechanism of GNNs (Wu et al., 2019;Zhu & Koniusz, 2020;Wu et al., 2022), which aims to learn the structural information in graphs. Meanwhile, another research direction in GNNs is the pooling mechanism, which follows the customs in CNN models that compress a set of nodes into a compact representation (Lee et al., 2019;Bianchi et al., 2020).
Besides the simplest pooling methods, that sum or average all nodes, various well-designed pooling approaches have been proposed to aggregate the node information in a hierarchical manner. However, despite the effectiveness of these methods on various tasks, there are still many issues that hinder the development of GNNs. First, pooling methods based on node drop, like TopKPool (Gao & Ji, 2019), SAGPool (Lee et al., 2019) and ASAP (Ranjan et al., 2020), unnecessarily cut nodes based on designed ranking strategy in each pooling layer, resulting in information loss (Baek et al., 2021). Although other methods based on node clustering avoid this issue (Ying et al., 2018;Bianchi et al., 2020), the damage on the graph local structure still can not be prevented due to the artificially specified node compression quota (Gao & Ji, 2019;Ranjan et al., 2020), which also exists in the node drop methods 1 . Furthermore, the cluster assignments produced by these works only rely on the topology of graph in the current layer without any consideration of the relationships among pooling layers. This would probably lead to suboptimal results in their tasks. Thus, a pooling operation that is globally optimized and has natural node partition is preferred.
In this paper, we present a hierarchical pooling method, termed SEP, to address the above two issues that hinder the development of GNNs (Figure 1). Specifically, inspired by structural entropy (Li & Pan, 2016), a metric designed to assess the graph structural information, the essential structure of a graph can be decoded by this metric as a measure of the complexity of its hierarchical structure. In particular, the cluster assignments for hierarchical pooling can be directly obtained from the proposed algorithm for structural entropy minimization. Note that, the proposed algorithm is globally optimized and free from learning, which means the cluster assignments will be generated together to avoid the suboptimal problem. Moreover, the algorithm does not rely on a fixed layer-specific compression quota but the number of compression layers, which would help retain the local structure of graphs.
Before the validation of SEP on classification benchmarks, we first present an illustration of the damage caused by previous hierarchical pooling methods on local structure of graphs. With seven benchmarks from bioinformatics and social networks, we then experimentally validate the effectiveness of SEP on tasks regarding graph classification, and conclude that SEP surpasses the state-of-the-art (SOTA) hierarchical pooling methods on most benchmarks especially on the social network datasets. Besides the superior performance on global attribute discerning, we further evaluate SEP on node classification tasks to better validate its capability of information retaining within the process of pooling. The results show that SEP outperforms the model with the same architecture (i.e., g-U-Nets) and most baselines. To sum up, our contributions are listed as follows: • We uncover two crucial issues in previous hierarchical pooling works that hinder the development of GNNs, including the local structure damage and suboptimal problem because of the fixed compression quota and stepwise pooling design.
• Through the introduction of the structural information theory, we present a novel hierarchical pooling approach, termed SEP, to address the unveiled issues.
• We extensively validate SEP on graph reconstruction, graph classification, and node classification tasks, in 1 The clustering-based pooling methods require the fixed number of clusters and the node drop methods require the fixed node compression ratio. which outperformances are observed in comparison the SOTA hierarchical pooling methods.

Related Work
Hierarchical pooling. To pursue better generalization and performance, pooling operations have been adopted to amplify the receptive fields and reduce the input sizes. Several designs are proposed from the angle of selecting the most important k nodes from the original graph to organize a new one, such as TopKPool (Gao & Ji, 2019), SAGPool (Lee et al., 2019) and ASAP (Ranjan et al., 2020). Though efficient, this node-drop design would result in information loss and isolated subgraphs, which will deteriorate the performance of GNNs. Thus, another design based on node clustering emerges and avoids this issue, including DiffPool (Ying et al., 2018) and MinCutPool (Bianchi et al., 2020), in which the nodes of original graph are merged into a bunch of clusters. Although preventing information loss, the damage on graph local structures still exists because of the fixed node compression quota.
Structural entropy. Information entropy stems from the demand for information measurement in communication systems (Shannon, 1948). Correspondingly, to measure the information in graphs, structural entropy was proposed and used to evaluate the complexity of the hierarchical structure of a graph (Li & Pan, 2016), which is also a natural node clustering method for graphs. Furthermore, twoand three-dimensional structural entropy, which measure the complexity of two-and three-level hierarchical structures, respectively, have been applied in medicine (Li et al., 2016b), bioinformatics (Li et al., 2018), and the security of networks (Li et al., 2016a). In the light of this global measurement of graph information, structural entropy can be used to decode the essential structure of graphs, which further sparks us the yielding of SEP to address the two issues that impede the development of GNNs.

Proposed Method
In this section, under the guidance of structural entropy, we present our key idea and an algorithm for the cluster assignments construction. Then, we design a GNN model, which has several convolutional layers and pooling layers, to learn global representations for graph classification. Furthermore, we develop another model, which is made up of additional convolutional layers and unpooling layers, to obtain local representations for node classification. Before elaborating on them, we first show some notations.

Preliminaries
A graph G can be represented as a multi-tuple (V, E, X), where |V| = n is the node set, |E| = m is the edge set, and X ∈ R n×d is the feature matrix for n nodes with ddimensional feature vector. The topology structure of graph G can be found in its adjacency matrix A ∈ R n×n .
Graph neural networks. In this work, we select Graph Convolutional Network (i.e., GCN (Kipf & Welling, 2017)) as the convolutional layers of our models. GCN and its variants have achieved excellent performance in different kinds of tasks regarding graphs. There is no doubt that our proposed pooling operator can also work with other GNNs like GAT (Veličković et al., 2018) and GIN (Xu et al., 2019). This will be discussed in the experimental section. For a stacked graph neural networks, the i-th convolutional layer in the form of GCN can be formally written as: where ReLU is a non-linear activation function, W i ∈ R h×h is the trainable matrix for this layer, H i+1 ∈ R n×h is the output of this layer and H 0 = X. In particular, A = A + I denotes the adjacency matrix with self-loops, andD ii = jÃ ij . In the process of hyper-parameter tuning, we fix the same hidden dimension for all layers.
Hierarchical pooling. In general, hierarchical pooling is a graph coarsening process to dig out a subset of representative nodes and form a new graph. Let S i ∈ R ni+1×ni denote the cluster assignment matrix at i-th pooling layer, where n i and n i+i are the number of nodes before and after graph coarsening. The new adjacency matrix and node feature matrix after pooling are calculated by the next equations: where A i ∈ R ni×ni is the adjacency matrix at the i-th layer and H i ∈ R ni×h refers to the node feature matrix produced by the i-th graph convolutional layer. Specifically, according to the cluster assignments S i , P i+1 receives the node hidden features H i and merges these features to refine the initial representations for the n i+1 clusters in the novel graph. Correspondingly, A i+1 employs the node connectivities A i to weave a more delicate origination among n i+1 clusters.

Cluster Assignments via Structural Entropy Minimization
Here, we present our methodology for hierarchical pooling. As claimed above, although plenty of works have been presented for graph coarsening based on heuristics or theories, little attention has been paid to the relationships among pooling layers. These studies only produce the cluster assignments based on the graph in the current layer. Meanwhile, in various tasks regarding graphs, there are graphs constructed from specific domain (e.g., social networks) or weaved by human (e.g., synthetic graphs), which are usually not optimal for GNNs because of noisy information. It is thus vital to eliminate such noisy structure from graphs in the process of cluster assignments generation. In this paper, inspired by structural entropy (Li & Pan, 2016), we propose a novel hierarchical pooling approach, denoted as SEP, to address the aforementioned issues in previous works. Besides the measurement of graph information, structural entropy can also be used to decode the hierarchical structure of a given graph as a metric of the complexity of its underlying essential structure. Thus, through structural entropy minimization, the hierarchical structure of a graph can be decoded into a corresponding coding tree, in which disturbance derived from noise or stochastic variation can be minimized (Li et al., 2018). We believe an effective structural entropy minimization algorithm could uncover the connections among hierarchical pooling layers and eliminate the noisy structure in graphs.
Based on the definition in (Li & Pan, 2016), let a two-tuple (V, E) be a graph G, the formal equation of the structural entropy for G on coding tree T can be written as: where v t is a nonroot node in T that can also be viewed as a node subset ⊂ V according to its leaf node partition in T , v + t is the parent of v t , g vt refers to the number of edges with an endpoint in the leaf node partition of v t , and vol(V) and vol(v t ) are the sums of degrees of leaf nodes in V and v t , respectively. The minimum entropy realized by the optimal coding tree T is the structural entropy of G, which follows this target equation: H(G) = min ∀T {H T (G)}. According to the definition of structural entropy, we know that the coding tree is a natural hierarchical division for graphs, and the connections among different layers are established for the purpose of structural entropy minimization. Furthermore, the local structure in graphs will be retained because we do not need to allocate layer-specific node compression quotas.
Besides the optimal coding tree that realizes the minimized structural entropy, in most cases, a natural coding tree with a certain height is preferred, because we only need a few fixed times of graph coarsening for most tasks (Gao & Ji, 2019;Baek et al., 2021). In this context, the k-dimensional structural entropy of G is proposed to decode the optimal coding tree with a fixed height k: In this paper, under the guidance of k-dimensional structural entropy, we aim to investigate the solution for decrypting the coding tree with a certain height k. Firstly, we define three functions.
Definition 3.1. Let T be any coding tree for graph G = (V, E), v r is the root node of T and V are the leaf nodes of T . Given any two nodes Definition 3.2. Following the setting in Definition 3.1, given any two nodes Definition 3.3. Following the setting in Definition 3.1, given any two nodes Based on the three defined functions, a greedy algorithm to compute the coding tree with a certain height k via structural entropy minimization can be found in Algorithm 1. Specifically, a full-height binary coding tree is first generated from bottom to top. In this stage, two child nodes of root are merged to form a new division in each iteration, which aims to maximize the structural entropy reduction. In the second stage, in order to satisfy a fixed number of graph coarsening, we need squeeze the previous full-height binary coding tree by dropping nodes. Each time, we select an inner-node from T , which makes T have the minimized structural entropy after removing this node. At the end of the second stage, we have already obtained a coding tree with a certain height k under the guidance of structural entropy. However, there may be nodes that do not have immediate successor in the next layer because of cross-layer links, which will cause node missing when realizing hierarchical pooling based on such a coding tree. Therefore, we need perform the third stage to ensure the integrity of information transmission between layers, and also need not interfere with the structural entropy of G on coding tree T (see Proposition 3.4). Finally, a coding tree T for the given graph G can be ob- In addition, the cluster assignment matrices can also be obtained from E T , that is, S = (S 1 , . . . , S k ). Proposition 3.4. Let T be a coding tree after the second stage of Algorithm 1, and given two adjacent nodes Algorithm 1 Coding tree with height k via structural entropy minimization Input: a graph G = (V, E), a positive integer k > 1 Output: a coding tree T with height k 1: Generate a coding tree T with a root node v r and all nodes in V as leaf nodes; 2: // Stage 1: Bottom to top construction; 3: while |v r .children| > 2 do 4: 10: REMOVE(v i ); 11: end while 12: // Stage 3: Fill T to avoid cross-layer links; 13: for end if 17: end for 18: return T ;

Proof. Equation 3 shows that the structural entropy of graph
According to Equation 3, we have: Complexity analysis. The runtime complexity of Algorithm 1 is O(2n + h max (m log n + n)), and h max is the height of coding tree T after the first stage. Meanwhile, since coding tree T tends to be balanced in the process of structural entropy minimization, h max will be around log n. Furthermore, graph generally has more edges than nodes, i.e., m n, thus the runtime of Algorithm 1 almost scales linearly in the number of edges.

Graph Neural Network for Graph Classification
In this subsection, we present the architecture based on SEP for graph classification, and name it SEP-G. As shown in Figure 2, the hierarchical pooling architecture follows the setting in previous pooling studies (Lee et al., 2019;Bianchi et al., 2020;Baek et al., 2021), which consists of three blocks and each block has a GCN layer and a SEP layer. For the graph-level representation, the outputs after each block are summarized and then fed to a prediction layer for classification. Based on Equations 1 and 2, the graph representation with SET-G can be formally written as: GCN SEP GCN SEP GCN SEP MLP Figure 2: The SEP-G architecture for graph classification. Following the design of previous works in hierarchical pooling, the architecture is comprised of three GCN layers and each is followed by corresponding SEP layer.
Permutation invariance. In graph classification, it is important to ensure the permutation invariance of designed graph neural network. In our proposed model for graph classification, there are two main components, that is, GCN layer and SEP layer. The permutation invariance of GCN layer has been confirmed by previous works (Ying et al., 2018;Ma et al., 2019). Thus, the SEP layer should be invariant with permutations.
Proof. The cluster assignments are derived from the coding tree via Algorithm 1, which is a traversal algorithm that does not depend on the order of nodes. Therefore, the generated assignments S will not change with any permutation. In addition, we know that the permutation matrix is orthogonal, thus PP = I with Equation 2 finishes the proof.

Graph Neural Network for Node Classification
Beyond the functionality of cluster assignments to convert graphs into high-level representations, we can also adopt the same matrix S i to unpool the compressed graph representation H i and structure A i to the original space by: In this context, we present an illustration of the architecture for node classification in Figure 3, and we call it SEP-N. SEP-N is an encoder-decoder network analogous to the design of g-U-nets (Gao & Ji, 2019). In the encoder, several down-sampling blocks are applied to encode higher-order features. Each block consists of a GCN layer and a SEP layer like our SEP-G. In the decoder, we employ the consistent number of decoding components. Thus, we can see the same GCN layer but with a SEP-U layer for unpooling in the decoder block. The skip-connections linking corresponding encoders and decoders are also adopted to enable spatial information transmission for better performance. Finally, a GCN layer is used to perform final predictions. There are two encoder and two decoder blocks and each block is composed of a GCN layer and a pooling (unpooling) layer. Skip connection links the same-level encoder and decoder to enhance spatial feature transmission.

Experiments
In this section, we describe the experiment setup for graph classification and node classification in detail, and validate the effectiveness of our proposed methods, SEP-G and SEP-N, in several corresponding benchmarks 2 .

Graph Reconstruction
Before the presentation of experiments regarding two major classification tasks in GNNs, we first employ a graph reconstruction experiment, which quantifies the structural information retained by pooling layer, to directly reveal the damage caused by previous hierarchical pooling methods to graph's local structures.
Configuration. An autoencoder is trained to reconstruct the input graph with pooling and unpooling layers. The learning objective is to minimize the mean square error (MSE) between input features X and output features X r , i.e., min X − X r 2 . For configuration, we employ the Synthetic graphs (Bianchi et al., 2020), including a ring and a grid that the input features are the coordinates of nodes in a 2-D Euclidean space. Detailed experiment configuration and model description can be found in Appendix A.1. Reconstruction results. Figure 4 shows the original graphs and the reconstructed graphs by model with various pooling methods. We select TopKPool to represent methods with node drop design and MinCutPool to represent methods with node clustering design 3 . We first notice the reconstructed results of TopKPool, where the basic shape of original graphs can not even be identified. This confirms that node drop methods will lead to severe information missing and implies the poor performance of node drop methods in graph classification. On the other hand, MinCutPool indeed retains the basic shape of original graphs. However, we can still see the significant distortion in the edge of ring and the center of grid, which represent the key structures of ring and grid, and this validates the assumption that the local structure in graphs would be ruined by the artificially specified node compression quota. On the contrary, SEP 3 Reconstruction results of all hierarchical pooling baselines can be found in Appendix A.1. almost reconstructs the ring and retains the essential structure in grid center which suggests that our pooling method obtains the key structural information of original graphs.

Graph Classification
Graph classification aims to label a given graph G with the maximum probability among several seed categories. To this end, we need learn the high-level representation from its component nodes, which enables the final classifier evaluate the likelihood of category that the graph belongs to.
Datasets. Seven benchmarks for graph classification are selected from TU datasets (Morris et al., 2020). Specifically, we employ three social network datasets, including IMDB-BINARY, IMDB-MULTI, and COLLAB; and four bioinformatics datasets, including MUTAG, PROTEINS, D&D and NCI1. Table 1 summarizes the characteristics of the seven employed datasets, and more detailed descriptions can be found in the Appendix A.2.
Configurations. Following (Xu et al., 2019;Lee et al., 2019), 10-fold cross-validation is conducted, and we present the average accuracies achieved to validate the performance of SEP-G in graph classification. In addition, the initial feature inputs is in line with the fair comparison setting in (Errica et al., 2020). Additional details about experiment setup can be found in the Appendix A.2.
Classification results. The classification accuracies of SEP-G and other baselines are shown in Table 1, and we can see that our method consistently achieves better or competitive performance as compared to these SOTA methods. In particular, SEP-G obtains a unified improvement in social network datasets, which differs from the performance in bioinformatics datasets. This performance divergence may be because SEP only relies on the network structure for hierarchical pooling, while the structural information in social network datasets is more redundant than that in bioinformatics datasets (Centola, 2010). It is worth noting that there are not any pooling methods suppress GIN in NCI1, or, put differently, pooling methods also do not show unified promotion in comparison with backbones. Considering the recent finding that message-passing is the crucial mechanism in graph classification (Mesquita et al., 2020), this phenomenon may not be so disappointing.
Variants of SEP-G. As discussed in Section 3.1, besides GCN, our proposed pooling operator can also work with other GNNs like GAT and GIN. Here, we delve deeper into the collaboration ability of our pooling method with other GNNs. Specifically, we employ the ChebNet (Defferrard et al., 2016), GraphSAGE (Hamilton et al., 2017), GAT (Veličković et al., 2018) and GIN (Xu et al., 2019). The classification results are shown in Table 2. As can be seen, the overall superior performance is obtained by these variants, which suggests the effectiveness and kindness of SEP. Notably, a better performance on IMDB-MULTI, PROTEINS, DD and NCI1 is obtained by SEP with GAT, which further indicates the huge potential of SEP in collaboration with other SOTA backbones.
Visualization case study. To better demonstrate the effectiveness of SEP on essential structure preserving, we present the clustering results of DiffPool, MinCutPool, and SEP on samples from the MUTAG dataset after the first graph coarsening. As shown in Figure 5, DiffPool and Min-CutPool severely damage the essential structures of the two compounds, in which the ring structures of two molecular formulas are arbitrarily torn into several pieces. Fortunately, SEP manages to take good care of these vital structures in the process of cluster assignment generation, and this shows the effectiveness of SEP in issues addressing.

Node Classification
Node classification is another important task regarding graphs in GNNs, which aims to label each node in a given graph G. Here, we conduct corresponding experiments on ubiquitous benchmarks to validate the effectiveness of our proposed SEP-N.
Datasets. We evaluate SEP-N under the transductive learning setting, which includes three datasets Cora, Citeseer and Pubmed (Sen et al., 2008). The three benchmarks are constructed on the connections of document citations, which means nodes are documents and edges are citation links. The node features are different among three datasets. Specifically, the input features of Cora and Citeseer are one-  (Kipf & Welling, 2017;Gao & Ji, 2019), the designated training/validation/testing splits on Cora, Citeseer and Pubmed are adopted, that is, training set has 20 nodes for each class, validation set has 500 nodes and testing set has 1,000 nodes. Table 3 shows the dataset statistics.
Baselines. In addition to g-U-nets (Gao & Ji, 2019) that has the same encoder-decoder design, we also include three SOTA backbones in GNNs: GCN (Kipf & Welling, 2017), GAT (Veličković et al., 2018), and GIN (Xu et al., 2019). Moreover, other following works based on the three models are also employed for a comprehensive comparison, such as FastGCN  Configurations. For node classification tasks, we fix our SEP-N with two blocks of encoders and decoders as presented in Figure 3, and plan to obtain the coding tree for each dataset under the guidance of three-dimensional structural entropy. In particular, each block has a GCN layer followed by a SEP (or SEP-U) layer. Finally, a GCN layer is adopted to make final prediction. There is no doubt that skip connections between layers are also established between encoder and decoder analogous to g-U-nets. Note that we add an additional linear layer after each SEP or SEP-U layer to learn more task-specific node representations. Dropout (Srivastava et al., 2014) with ReLU on feature matrices is applied to all layers in SEP-N, and L2 regularization is also adopted to avoid over-fitting. Detailed descriptions for experimental setup are shown in Appendix A.3.
Classification results. The accuracies of our proposed SEP-N and baselines on three benchmarks are shown in Table 3. In general, we can observe that the SEP-N does not achieve the best performance on any datasets, which are shown in S 2 GC on Citeseer and GCNII on Cora and Pubmed. This problem may be attributed to the cluster assignments generation, which only relies on structural in-formation, while the tasks regarding node classification are more dependent on the input features of nodes. However, SEP-N still obtains competitive results with only 5 GCN layers, which is much less than the design of S 2 GC (16) and GCNII (64 for Cora, 32 for Citeseer, 16 for Pubmed). In particular, the accuracies of SEP-N on three datasets are consistently better than the three backbones (i.e., GCN, GAT and GIN). Furthermore, compared with g-U-nets, which is also designed with GCN and hierarchical pooling mechanism, our method also surpasses it on two out of three datasets (Cora and Pubmed) even with fewer learning blocks. Note that superior performance of SEP-N on Citeseer has also been achieved with different numbers of blocks, which we will describe it in the next experiments. In summary, we can confirm the effectiveness of the proposed hierarchical pooling operation in node representation learning. Ablation Study of Network Depth. Besides the other bunch of hyper-parameters in GNNs, the network depth, corresponding to the number of blocks, is also another cru-  Table 4. As we mentioned above, SEP-N achieves superior performance on Citeseer with only one encoder and decoder. In particular, compared with g-U-Nets, we can see that the best performance of SEP-N on three datasets is achieved with at most 2 blocks, which once again proves the capacity of shallow networks in high-level feature encoding (Gao & Ji, 2019). Moreover, this scene also reveals that additional connection information among layers for cluster assignments generation is helpful for representation learning, as well as benefits model optimization that better performance with fewer parameters and computations.

Conclusions
In this paper, we develop an optimization algorithm to address several limitations of existing hierarchical pooling approaches. In particular, under the guidance of structural entropy minimization, our pooling method, SEP, can not only capture the connectivities among pooling layers but also fix the problem of destroying local structure due to the hyper-parameter for node compression. Based on the proposed SEP, we introduce two learning models, SEP-G and SEP-N, for graph classification and node classification, respectively. Experimental results suggest that SEP-G achieves significant improvements on graph classification, and SEP-N obtains superior performance as compared to other GNNs on node classification tasks. An interesting direction for future work is shown in the combination of structural entropy and node features.

A. Experiment Setup
In this section, we introduce the experimental details about graph reconstruction, graph classification, and node classification tasks respectively.

A.1. Graph Reconstruction
Dataset. Graph reconstruction experiments with synthetic graphs represented in a 2-D Euclidean space, such as ring and grid structures. The node features of a graph consist of their location in a 2-D coordinate space, and the adjacency matrix indicates the connectivity pattern of nodes. The goal here is to restore all node locations from compressed features after pooling, with the intact adjacency matrix. Implementation details. Following (Bianchi et al., 2020), we use the two message passing layers both right before the pooling operation and right after the unpooling operation. Also, both pooling and unpooling operations are performed once and sequentially connected, as illustrated in the Figure A.1. We compare our methods against both the node drop methods, including TopKPool (Gao & Ji, 2019), SAGPool (Lee et al., 2019) and ASAP (Ranjan et al., 2020), and node clustering methods, including DiffPool (Ying et al., 2018) and MinCutPool (Bianchi et al., 2020). For the node drop methods, we use the unpooling operation proposed in the graph U-net (Gao & Ji, 2019). For the node clustering methods, we use the graph coarsening schemes described in the Equation 15, with their specific implementations on generating an assignment matrix. For our proposed method, we follow the setting of node clustering methods. In particular, we finely tuned the height of coding tree produced by Algorithm 1 to make sure the number of nodes compressed in the first layer close to the setting of baselines. For model configuration, the pooling ratio of all models is set to 25%, the learning rate is set to 5 × 10 −3 , and hidden size is set to 32. For the loss function, we use the Mean Squared Error (MSE) to train models. We then optimize the network with Adam optimizer. We use the early stopping criterion, where we stop the training if there is no further improvement on the training loss during 1,000 epochs. Further, the maximum number of epochs is set to 10,000. Note that, there is no other available graphs for validation of the synthetic graph, such that we train and test the models only with the given graph in the Figure 3(a).

GCN
Reconstruction results on all hierarchical pooling methods. Figure A.2 and A.3 show the results of reconstructed graphs by model with various pooling methods. As can be seen from the first row of Figure A.2 and A.3, the node drop methods suffer from the issue of information loss, resulting in the basic shape of original graphs can not be identified. For node clustering methods, DiffPool and MinCutPool, the basic shape of original graphs is basically retained. However, we can still see the significant distortion in the edge of ring and the center of grid, which are almost prevented in SEP.

A.2. Graph Classification
Social network datasets. IMDB-BINARY and IMDB-MULTI are derived from the collaboration of a movie set. In these two datasets, every graph consists of actors or actresses, and each edge between two nodes represents their cooperation in a certain movie. Each graph is derived from a prespecified movie, and its label corresponds to the genre of this movie. Similarly, COLLAB is also a collaboration dataset but from a scientific realm, which includes three public collaboration datasets (i.e., Astro Physics, High Energy Physics and Condensed Matter Physics). Many researchers from each field form various ego networks for the graphs in this benchmark. The label of each graph is the research field to which the nodes belong.
Bioinformatic datasets. D&D contains graphs of protein structures. A node represents an amino acid and edges are constructed if the distance of two nodes is less than 6Å. A label denotes whether a protein is an enzyme or non-enzyme. PROTEINS is a dataset where the nodes are secondary structure elements (SSEs), and there is an edge between two nodes if they are neighbors in the given amino acid sequence or in 3D space. The dataset has 3 discrete labels, representing helixes, sheets or turns. PTC is a dataset containing 344 chemical compounds that reports the carcinogenicity of male and female  rats and has 19 discrete labels. NCI1 is a dataset made publicly available by the National Cancer Institute (NCI) and is a subset of balanced datasets containing chemical compounds screened for their ability to suppress or inhibit the growth of a panel of human tumor cell lines; this dataset possesses 37 discrete labels. MUTAG has seven kinds of graphs that are derived from 188 mutagenic aromatic and heteroaromatic nitro compounds. PTC includes 19 discrete labels and reports the carcinogenicity of 344 chemical compounds for male and female rats.
Initial inputs. The data of the bioinformatic datasets and social network datasets differ in that the nodes in bioinformatics graphs have categorical labels that do not exist in social networks. Thus, the initial node features of the HRN inputs are set to one-hot encodings of the node degrees for social networks and a combination of the one-hot encodings of the degrees and categorical labels for bioinformatic graphs.
Implementation details. We evaluate the model performance with a 10-fold cross validation setting, where the dataset split is based on the conventionally used training/test splits Bianchi et al., 2020;Baek et al., 2021). In addition, we use the 10 percent of the training data as a validation data following the fair comparison setup (Errica et al., 2020). We use the early stopping criterion, where we stop the training if there is no further improvement on the validation loss during 50 epochs. Furthermore, the maximum number of epochs is set to 500. We then report the average performances on test sets, by performing overall experiments 10 times. In particular, following the implementation of (Xu et al., 2019), we train each epoch with a fixed number of iterations (i.e., 50) for small datasets. We set the pooling ratio as 25% in each pooling layer for baselines as previous works (Baek et al., 2021;Bianchi et al., 2020), while our model follows the natural cluster assignments produced by Algorithm 1 with given height 3. For model configuration, the learning rate is set to 5 × 10 −4 , the hidden size is set ∈ {64, 128}, the batch size is set ∈ {32, 128}, weight decay is set to 1 × 10 −4 , and dropout rate is set ∈ {0, 0.5}. Then we optimize the network with Adam optimizer. For a fair comparison of baselines (Lee et al., 2019), we use the three GCN layers (Kipf & Welling, 2017) as a message passing function for all models with skip connections, and only change the pooling architecture throughout all models. Because GMT is the most recent work that replicates these popular pooling approaches in previous studies, and we implement SEP-G based on the code of GMT 4 , thus the accuracies of baselines are derived from (Baek et al., 2021).

A.3. Node Classification
Citation datasets. We utilize three standard citation network benchmark datasets: Cora, Citeseer and Pubmed (Sen et al., 2008). In all of these datasets, nodes correspond to documents and edges to (undirected) citations. Node features correspond to elements of a bag-of-words representation of a document. Each node has a class label. In particular, the node features are different among three datasets. Specifically, the input features of Cora and Citeseer are one-hot embedding of words in each document, while the node features of Pubmed are the TF-IDF weighted word vectors. The Cora dataset contains 2708 nodes, 5429 edges, 7 classes and 1433 features per node. The Citeseer dataset contains 3327 nodes, 4732 edges, 6 classes and 3703 features per node. The Pubmed dataset contains 19717 nodes, 44338 edges, 3 classes and 500 features per node.
Implementation details. We closely follow the transductive experimental setup in (Kipf & Welling, 2017). Each class is only allowed 20 nodes for training, which honors the transductive setup, and the training algorithm has access to all of the nodes' feature vectors. The predictive power of the trained models is evaluated on 1000 test nodes, and we use 500 additional nodes for validation purposes. We also use the early stopping criterion, where we stop the training if there is no further improvement on the validation loss during 50 epochs. Furthermore, the maximum number of epochs is set to 1000. We obtain cluster assignment matrices of each dataset under the guidance of three-dimensional structural entropy, and adopt the first two layers for hierarchical pooling. For model configuration, the learning rate is set to 0.01, the hidden size is set ∈ {16, 32, 128, 256}, weight decay is set ∈ {0.02, 5 × 10 −4 }, and dropout rate for each layer is set ∈ {0, . . . , 0.9}. Finally, we optimize the network with Adam optimizer.
Fair comparison with SOTA methods. To make a fair comparison with S 2 GC and GCNII, we present the results of the two methods with similar convolutional layers. As shown in Table A.1, SEP-N obtains competitive results with only 5 GCN layers, which is much less than the requirement of S 2 GC (16) and GCNII (64 for Cora, 32 for Citeseer, 16 for Pubmed). Furthermore, SEP-N outperforms S 2 GC and GCNII when putting similar number of convolution layers, which reveals the effectiveness of hierarchical graph pooling in node classification tasks when facing limited computing resources. Model (#Convs) S 2 GC(4) S 2 GC(8) GCNII(4) GCNII (8)