Title: MXPOOL: MULTIPLEX POOLING FOR HIERARCHICAL GRAPH REPRESENTATION LEARNING

Abstract: Graphs are known to have complicated structures and have myriad applications. How to utilize deep learning methods for graph classification tasks has attracted considerable research attention in the past few years. Two properties of graph data have imposed significant challenges on existing graph learning techniques. (1) Diversity: each graph has a variable size of unordered nodes and diverse node/edge types. (2) Complexity: graphs have not only node/edge features but also complex topological features. These two properties motivate us to use a multiplex structure to learn graph features in a diverse way. In this paper, we propose a simple but effective approach, MxPool, which concurrently uses multiple graph convolution networks and graph pooling networks to build hierarchical learning structure for graph representation learning tasks. Our experiments on numerous graph classification benchmarks show that our MxPool has marked superiority over other stateof-the-art graph representation learning methods. For example, MxPool achieves 92.1% accuracy on the D&D dataset while the second best method DiffPool only achieves 80.64% accuracy.

1. INTRODUCTION:

Graphs are known to have complicated structures and have myriad of real world applications. Recently, great efforts have been put on utilizing deep learning methods for graph data analysis. Many newly proposed graph learning approaches are inspired by Convolutional Neural Networks (CNNs) (LeCun & Bengio, 1998) , which have been greatly successful in learning two-dimensional image data (grid structure). The convolution and pooling layers in CNNs have been redefined to process graph data. Multitude of different Graph Convolutional Networks (GCNs) (Shuman et al., 2013) have been proposed, which can learn node level representations by aggregating feature information from neighbors (spatial-based approaches) (Hamilton et al., 2017) or by introducing filters from the perspective of graph signal processing (spectral-based approaches) (Bengio & LeCun, 2014) . On the other hand, similar to the original pooling layer which comes with CNNs, graph pooling module (Defferrard et al., 2016; Zhang et al., 2018) could easily reduce the variance and computation complexity by down-sampling from original feature data, which is of vital importance, particularly for graph level classification tasks. Recently, hierarchical pooling methods that can learn hierarchical representations of graphs have been proposed (Ying et al., 2018; Gao & Ji, 2019; Lee et al., 2019) and shows state-of-the-art performance for graph classification tasks.

However, two properties of graph data have imposed significant challenges on existing graph learning techniques. 1) Diversity: each graph has a variable size of unordered nodes and has diverse node/edge types. 2) Complexity: graphs have not only node/edge features but also complex topological features. These two properties can bring troubles in both of the graph convolution operation and the graph pooling operation.

For example, when performing node-representation learning tasks (by graph convolution operation), it is enough to use small output embedding size for simple and small graphs, as shown in Figure 1 (a), since large embedding size could result in overfitting problem. By contrast, it is necessary to set large output embedding sizes for complex and large graphs to learn complex graph structure properties, as shown Figure in 1(b) . This creates a contradiction when processing a set of irregular graphs. For another example, when coarsening graphs (by graph pooling operation), if more attention is put on the graph structure, we may obtain a coarsened graph as shown in Figure 1(c ). If more attention is put on the node features, we may obtain another coarsened graph as shown in Figure 1 (d) . This creates another contradiction when processing graphs with not only node features but also topological features. 

2. RELATED WORK:

In this section, we review the recent literature on GNNs, graph convolution variants, and graph pooling variants.

Graph Neural Networks Inspired by Traditional Deep Learning Techniques. GNNs have recently drawn considerable attention due to their superiority in a wide variety of graph related tasks, including node classification (Kipf & Welling., 2017) , link prediction (Schlichtkrull et al., 2018) , and graph classification (Dai et al., 2016) (Ma et al., 2018) proposes using LSTM (Hochreiter & Schmidhuber, 1997) to learn node representations in dynamic graphs. Inspired by the attention mechanism (Vaswani et al., 2017) Graph Attention Networks (GATs) (Velickovic et al., 2017) introduce attentions into GCNs by differentiating the influence of neighbors. Graph Au-toEncoders (GAEs) (Wang et al., 2016) origin from the autoencoder mechanism widely used for unsupervised learning and are suitable to learn node representations for graphs. GCPN (You et al., 2018b) utilizes Reinforcement Learning (RL) for goal-directed molecular graph generation.

Graph Convolution. Graph convolution operations fall into two categories, spectral-based approaches and spatial-based approaches. Bengio & LeCun (2014) first introduce convolution for graph data from spectral domain using the graph Laplacian matrix L. Besides, there exist numerous spectral-based graph convolution methods, such as ChebNet (Defferrard et al., 2016) , 1stChebNet (Kipf & Welling, 2017) , and AGCN (Li et al., 2018) . In contrast, spatial-based convolution methods define graph convolution based on a node's spatial relations. It takes the aggregation of a node representation and its neighbors' representations to obtain a new representation for this node. In order to explore the depth and breadth of a node's receptive field, multiple graph convolution layer are stacked together, so that the features of two or more hops away neighbors can be learned. For example, GGNNs (Li et al., 2015) , MPNN (Gilmer et al., 2017) , GraphSage (Hamilton et al., 2017) , PATCHY-SAN (Niepert et al., 2016) , and DCNN (Atwood & Towsley, 2016) all fall into the spatial-based category.

Graph Pooling. Graph pooling operation is of vital importance for graph classification tasks (Zhang et al., 2018) . It coarsens a graph into sub-graphs (Defferrard et al., 2016; Ying et al., 2018) or to sum/average over the node representations (Duvenaud et al., 2015; Gilmer et al., 2017) , which can obtain a compact representation on graph level. The graph coarsening approaches obtain hierarchical graph representations either by using deterministic pooling methods or by using learned pooling methods. The deterministic pooling methods (Defferrard et al., 2016; Simonovsky & Komodakis, 2017) utilizes graph clustering algorithms to obtain next level coarsened graph that is going to be processed by GNNs, following a two-stage approach. On the other hand, the learned pooling methods (Ying et al., 2018; Lee et al., 2019; Diehl, 2019; Gao & Ji, 2019) seek to learn the hierarchical structure, which have shown to outperform deterministic pooling methods. DiffPool (Ying et al., 2018) was the first to propose learned graph pooling. It learns a soft cluster assignment matrix in layer l which contains the probability values of nodes being assigned to clusters.

A cluster in layer l will be reduced to a node in layer l + 1. A GNN with input node features and adjacency matrix is used to generate the soft assignment matrix, based on which we can learn the cluster embeddings (i.e., node features in the next layer) and the coarsened adjacency matrix denoting the connectivity strength between each pair of the clusters. Besides DiffPool, numerous graph pooling methods have emerged recently, including gPool (Gao & Ji, 2019) , SAGPool (Lee et al., 2019) , EigenPooling (Ma et al., 2019) , and Relational Pooling (Murphy et al., 2019) . This paper will focus on the learned pooling.

3. PROPOSED METHOD:

In this section, we propose MxPool to learn graph representations such that graph level classification can be applied. Before going to the details, we first introduce some notations and the problem setting.

Problem Setting A graph can be represented as G = {A, F }, where A ∈ R n×n denotes the adjacency matrix (n is the number of nodes contained in G), and F ∈ R N ×d denotes the node feature matrix (d is the dimension of features). In the graph classification setting, given a set of graphs and each being associated with a label, we aim to train a model that takes an unseen graph as input and predicts its corresponding label. To make the prediction, it is important to extract useful information from multiple perspectives including both graph structure and node features.

3.1. OVERVIEW:

MxPool is a multi-layer hierarchical GNN model. At each layer, MxPool consists of convolution operation and pooling operation. The convolution operation aims to learn node-level representations, while the pooling operation aims to learn a coarsened graph. The new coarsened graph can then be used as input to next layer. This process can be repeated several times, generating a multi-layer GNN model to learn hierarchical graph representations. The convolution operation and pooling operation are both important for graph representation learning. To simplify the illustration, we choose GCN (Kipf & Welling., 2017) as the convolution layer and DiffPool (Ying et al., 2018) as the pooling Different from other hierarchical GNNs, MxPool launches multiple GCNs to learn node-level representations and also launches multiple pooling networks to coarsen the graph. The node-level representations resulted from multiple GCNs are then merged in a learnable way, and the coarsened graphs resulted from multiple pooling networks are also merged. The merged node embeddings and the merged coarsened graph are used to generate a new coarsened graph with a new set of node features. This multiplex structure can help extract useful information from different perspectives (e.g., graph structure perspective and node feature perspective) and can adapt to graphs with different sizes. We provide an illustrative example as shown in Figure 3 .

The procedure of the GCN (Kipf & Welling., 2017) is to "horizontally" learn node representations, as it can only "pass message" between nodes through edges. The procedure of differentiable pooling (Ying et al., 2018) is to "vertically" summarize the node features into the higher level graph representation. The procedure of multiplexing is to "diversely" learn node representations or graph representations from different perspectives. The procedure of merging is to "synthetically" learn the diverse results and put more attention to one or more perspectives. Since the convolution, pooling, and merging operations are all differentiable, we can define an end-to-end differentiable graph representation learning framework in a hierarchical manner.

3.2. MULTIPLEX CONVOLUTION:

In our model, we use GCN for the convolution operation. The original GCN (Kipf & Welling., 2017) is stacked by several convolutional layers, and a single convolutional layer can be written as

EQUATION

where H (k) ∈ R n×d are the node embeddings computed after k steps, Ã = A+I, D = ∑ j Ãij , and W (k) ∈ R d×d is a trainable weighted matrix2 . Equation (1) can be understood as a message passing process. The node embeddings H (k) are the "messages" transferred along edges, which are going to be used to generate new node embeddings in next round. A total number of K convolutional layers are stacked to learn node representations and the output matrix Z = H K can be viewed as the final node representations learned by the GCN model.

In multi-layer GNN, suppose there are totally L layers. At each layer l, with the input node feature matrix X l ∈ R n l ×d l and the adjacency matrix A l ∈ R n l ×n l generated from previous layer, we learn an embedding matrix Z (l) ∈ R n l ×d l+1

. Here, we use d l+1 to denote the output embeddings' dimension since it will determine the input node embeddings X (l+1) at next layer l + 1 that will be introduced later. For simplicity's sake, we will use Z (l) = GCN c (A (l) , X l ) to denote the GCN process (containing K iterations of message passing). Initially, A (0) = A ∈ R n×n is the original graph's adjacency matrix, and X (0) = F ∈ R n×d is the original graph's node features.

In MxPool, we use multiple GCNs to learn multiple sets of node embeddings. These GCNs can be trained with different sets of hyperparameters θ, such as weight matrix W 's dimension. Suppose there are n c GCNs running concurrently at each layer l, we will have n c sets of node embeddings {Z i resulted from the ith GCN as follows:

Z (l) i = GCN c (A (l) , X l , θ i ).

(2)

Then, the multiple sets of node embeddings {Z

(l) 1 , Z (l) 2 , . . . , Z (l)

nc } are merged into one set of node embeddings Z (l) using a neural network:

EQUATION

where "||" denotes row-wise concatenation operation and f c () is a trainable neural network. One important hyperparameter of f c () is the output embeddings' dimension d l+1 , i.e., Z (l) ∈ R n l ×d l+1 . We set d l+1 by averaging the dimensions of the multiple weight matrices {W 1 , W 2 , . . . , W nc }.

Suppose W i ∈ R n l ×d l i , we can set d l+1 = ∑ nc i=1 d l i /n c .

3.3. MULTIPLEX POOLING:

We follow DiffPool (Ying et al., 2018) to construct our multiplex pooling layer. We learn to assign nodes to clusters at each layer l using node embeddings and adjacency matrix generated from previous layer. Specifically, at each layer l, we learn n p cluster assignment matrices {S 1 , S 2 , . . . , S np }, and each cluster assignment matrix S i is generated as follows:

EQUATION

)

It is noticeable that GCN p is a GCN different from the GCN c used in the convolution layer, though these two GNNs consume the same input data. Each row of S (l)

i corresponds to one of the n l nodes at layer l, and each column of S (l) i corresponds to one of the c l i clusters, so that we have S (l)

i ∈ R n l ×c l i . 0 < µ i < 1 denotes the hyperparameters set of the ith GCN. One important hyperparameter could be the compression ratio that determines the number of clusters to be assigned, i.e., c l i . Different pooling networks can use different number of clusters.

Similar to the merging process in the convolution operation, these generated assignment matrices

{S (l) 1 , S (l) 2 , . . . , S (l)

np } are merged into a single assignment matrix S (l) using a neural network:

EQUATION

where "||" denotes row-wise concatenation operation and f g () is a trainable neural network. Given the number of nodes at the next layer l + 1, n l+1 , we should configure f g () to output an assignment matrix with n l+1 columns, i.e., S (l) ∈ R n l ×n l+1 .

Following the pooling approach proposed in (Ying et al., 2018) , we then use the merged node embeddings Z (l) as shown in Equation ( 3) and the merged assignment matrix S (l) as shown in Equation ( 5) to generate embeddings for each of the n l+1 clusters. We also take the adjacency matrix A (l) and the merged assignment matrix S (l) to generate a coarsened adjacency matrix denoting the edge weights between each pair of cluster:

EQUATION

Here, since S (l) ∈ R n l ×n l+1 and Z (l) ∈ R n l ×d l+1 , we have the cluster embeddings X (l+1) ∈ R n l+1 ×d l+1

. Similarly, we have the coarsened adjacency matrix A (l+1) ∈ R n l+1 ×n l+1

Note that, the coarsened graph is a fully connected weighted graph, so that the coarsened adjacency matrix A (l+1) is a real matrix and each entry in A (l+1) denotes the edge weight between two clusters. The cluster embeddings X (l+1) and the coarsened adjacency matrix A (l+1) will then be used as input to the next layer, where one cluster at layer l corresponds to one node at layer l + 1.

4. EXPERIMENTS:

In this section, we compare MxPool with the state-of-the-art graph representation learning methods in the context of graph classification task.

Datasets.:

In our experiments, we use four graph data sets chosen from benchmarks commonly used in graph classification. These include D&D (Dobson & Doig, 2003) , ENZYMES (Borgwardt et al., 2005) , PROTEINS (Dobson & Doig, 2003; Borgwardt et al., 2005) , NCI109 (Wale et al., 2008) , and COLLAB (Yanardag & Vishwanathan, 2015) . Each of these datasets include hundreds to thousands graphs. The details of these datasets are provided in Table 1 . Model Configurations. We implement MxPool by modifying DiffPool. The convolution GNN model used is the "mean" variant of GraphSAGE (Hamilton et al., 2017) architecture, which is similar to the GCN and provides various aggregation methods. The pooling GNN model used is the DiffPool model. The model configurations for convolution GNN and pooling GNN is the same as DiffPool. Besides, our MxPool comprises multiple graph convolution networks and multiple graph pooling networks with different sets of hyperparameters to learn graph features from different perspectives. Besides the hyperparameters used in each convolutional/pooling GNN, the number of graph convolution networks and the number of graph pooling networks are two hyperparameters. We concurrently run 3 graph convolution networks and also concurrently run 3 graph pooling networks. The learning rate is set as 0.001. Regarding the ENZYMES dataset, since there exist 6 classes, we use cross entropy to compute the loss.

4.1. BASELINES AND EXPERIMENTAL SETTINGS:

We consider the following state-of-the-art methods for graph classification task as baselines:

GraphSAGE (Hamilton et al., 2017 ) is a graph convolution framework proposed for semisupervised node classification. GraphSAGE with global mean-pooling on the learned node representations can realize graph representation learning so that it can be used for graph classification task. Other graph convolution variants are omitted as empirically GraphSAGE obtained higher performance in the task (Hamilton et al., 2017) .

SortPool (Zhang et al., 2018 ) is a global pooling method which uses sorting for pooling. It is built upon the GCN layer, where the features of nodes are sorted before feeding them into traditional 1D convolutional and dense layers. SAGPool (Lee et al., 2019 ) is a Self-Attention Graph Pooling method for GNNs in the context of hierarchical graph pooling. The self-attention mechanism is exploited to distinguish between the nodes that should be dropped and the nodes that should be retained.

DiffPool (Ying et al., 2018) is the first end-to-end trainable graph pooling method that learns hierarchical representations of graphs. By setting a compression ratio parameter r, a graph with n nodes is coarsened into a graph with n • r nodes at each layer. We also implement our method based on DiffPool.

Experimental Setup In order to remove unwanted bias towards the training data, we use 10-fold cross validation for all the baselines and our approach. Since GraphSAGE and DiffPool are the two key components in our MxPool approach (GraphSAGE as the graph convolution layer and DiffPool as the graph pooling layer), we use the base implementation and hyperparameter sweeps as in our MxPool approach. Regarding the hyperparameters of SortPool, gPool, and SAGPool, we follow the same experimental setups described in their original papers. In addition, we adopt the widely used evaluation metric, i.e., accuracy, for graph classification to evaluate the performance.

4.2. PERFORMANCE ON GRAPH CLASSIFICATION:

The graph classification performance in ter90o8ims of accuracy is reported in Table 2 . For all the baselines, we use 10-fold cross validation numbers reported by the original authors if we can obtain the numbers close to the reported ones. Regarding the gPool baseline (Gao & Ji, 2019) , we cannot obtain the necessary published numbers, so we use the numbers on the ENZYMES dataset and PRO-TEINS dataset reported by the third-party3 and the number on D&D dataset reported by Lee et al. (2019) . For the other datasets, we use the numbers tested by ourselves. Regarding the SAGPool baseline (Lee et al., 2019) , we meet RuntimeError when processing the ENZYMES dataset and COLLAB dataset, and we denote this case by '-'.

From the table, we observe that our MxPool approach shows remarkable performance improvement over the other state-of-the-art baselines on the first four datasets. Especially on the D&D dataset, MxPool improves the performance of the second-best approach DiffPool over 11%. However, Diff-Pool performs slightly better than MxPool on the COLLAB dataset. We tested DiffPool by ourselves and could only obtain 71.78% accuracy, which is lower than the number 75.48% reported in the original paper. This may be due to the unoptimized parameter settings, but we still use the reported number 75.48% for the DiffPool baseline. In addition, GraphSAGE and DiffPool are the two basic components in our multiplex model, working as the convolution layer and the pooling layer, respectively. MxPool improves upon the base convolution GNN (i.e., GraphSAGE) by an average of 9.39% and improves upon the base pooling GNN (i.e., DiffPool) by an average of 3.62%.

4.3. ANALYSIS OF MULTIPLEX CONVOLUTION/POOLING:

Our motivation for this work is to utilize multiplex hierarchical structure to deal with the diversity and complexity challenges in graph representation learning. Multiple graph convolutional networks In order to verify the effectiveness of multiplex convolution and multiplex pooling, we run our MxPool with single convolution network and single pooling network (SCSP), multiple convolution networks and single pooling network (MCSP), single convolution network and multiple pooling networks (SCMP), and multiple convolution networks and multiple pooling networks (MCMP), respectively. The accuracy results for graph classification are shown in Table 3 . Since the suitable node embedding sizes and compression ratios are not consistent for different datasets, we use c 1 , c 2 , c 3 to denote three different graph convolution parameters (i.e., node embedding size) and p 1 , p 2 , p 3 to denote three different graph pooling parameters (i.e., compression ratio). Note that, they are different for different datasets. We have put the detailed parameter settings on our GitHub project page.

From the table, we observe that the multiplex structure significantly improves performance over the singular structure. By fixing the pooling network with p 1 , multiplexing three convolution networks with hyperparameters [c 1 |c 2 |c 3 ] performs much better than using single convolution network with either c 1 , c 2 , or c 3 . A similar trend can be observed when multiplexing pooling networks. Anyhow, the best choice is to simultaneously multiplex convolution networks and multiplex pooling networks (i.e., MCMP).

4.4. NUMBER OF CONVOLUTION/POOLING NETWORKS:

The number of convolution/pooling networks is a hyperparamter in MxPool. In the previous experiments, we use a fixed number of convolution/pooling GNNs to show the performance. In this experiment, we vary the number of convolution/pooling networks from 1 to 6 and test the performance. Our results listed in Appendix A show that the performance can be improved a lot when the number is set to 3. But as the number is increased larger, the performance is reduced. This may be because that too many networks with a large amount of parameters result in overfitting problem.

5. CONCLUSION:

In this paper, we proposed a simple but effective multiplex GNN architecture MxPool for hierarchical graph representation learning. MxPool comprises multiple graph convolution networks to learn node-level representations and also comprises multiple graph pooling networks to coarsen the graph. The diversity challenge and the complexity challenge of graph representation learning can be well addressed in our proposed approach. Our results show that MxPool has remarkable performance improvement over the state-of-the-art graph representation learning methods. Future work includes designing unpooling layers to form an encoder-decoder learning structure to deal with node classification tasks and link prediction tasks.

:

Our code is available at https://github.com/JucatL/MxPool/.

The number of dimensions of W can be different from d, i.e., W ∈ R d×o , where o denotes the output embedding's size.

https://github.com/bknyaz/graph nn

Figures and Tables:

Figure 1: Multiple graph convolution networks with different output node embedding sizes are needed since graph sizes and complexities are not consistent, e.g., (a) and (b). Multiple graph pooling networks are needed to coarsen graphs according to different graph properties. For example, the original graph can be coarsened according to graph structure as shown in (c) or according to node features as shown in (d), where circle vertices have similar node features and triangle vertices have similar node features.

Let θ i be the hyperparameters set of the ith GCN. Then at layer l, we have node embeddings Z (l)

). Multiple graph pooling networks are needed to coarsen graphs according to different graph properties. For example, the original graph can be coarsened according to graph structure as shown in (c) or according to node features as shown in (d), where circle vertices have similar node features and triangle vertices have similar node features.

Table content: <table><tr><td>For example, MxPool achieves 92.1% accuracy on the D&amp;D dataset while the second best method</td></tr><tr><td>DiffPool only achieves 80.64% accuracy.</td></tr></table>

An illustrative example of MxPool. At each hierarchical layer, we first run multiple GCNs with different hyperparameters on the original graph, so we will have multiple diverse sets of node embeddings, which form the multiplex convolution step. Next, we use a learnable approach to merge these embeddings for each node into one. We also run multiple differentiable pooling operations on the original graph and cluster nodes together in diverse ways, which forms the multiplex pooling step. These coarsened graphs are then merged into one in a learnable approach. The merged node embeddings and the merged coarsened graph are used to generate a new coarsened graph with a new set of node features, which is going to be processed in the next hierarchical layer.

Table content: <table><tr><td/><td/><td/><td>Next</td></tr><tr><td/><td/><td/><td>hierarchical</td></tr><tr><td>Multiplexing</td><td>embeddings Node</td><td>Merge</td><td>... layer</td></tr><tr><td/><td/><td>Multiplex Pooling</td><td/></tr><tr><td/><td>Node</td><td/><td/></tr><tr><td/><td>embeddings</td><td/><td/></tr><tr><td/><td>Multiplex Convolution</td><td>Multiplexing</td><td>Merge</td></tr><tr><td>Figure 2:</td><td/><td/><td/></tr></table>

Statistics of data sets.

Table content: <table><tr><td>Dataset</td><td colspan="5"># of graphs # of classes max # of nodes avg # of nodes avg # of edges</td></tr><tr><td>D&amp;D</td><td>1178</td><td>2</td><td>5748</td><td>284.32</td><td>715.66</td></tr><tr><td>ENZYMES</td><td>600</td><td>6</td><td>126</td><td>32.63</td><td>62.14</td></tr><tr><td>PROTEINS</td><td>1113</td><td>2</td><td>620</td><td>39.06</td><td>72.82</td></tr><tr><td>NCI109</td><td>4127</td><td>2</td><td>111</td><td>29.68</td><td>32.13</td></tr><tr><td>COLLAB</td><td>5000</td><td>3</td><td>492</td><td>74.49</td><td>2457.78</td></tr></table>

Performance comparison on graph classification.

Table content: <table><tr><td>Baselines</td><td colspan="5">D&amp;D ENZYMES PROTEINS NCI109 COLLAB</td></tr><tr><td colspan="2">GraphSAGE (Hamilton et al., 2017) 75.42</td><td>54.25</td><td>70.48</td><td>76.50</td><td>68.25</td></tr><tr><td>SortPool (Zhang et al., 2018)</td><td>79.37</td><td>57.12</td><td>75.54</td><td>70.80</td><td>73.76</td></tr><tr><td>gPool (Gao &amp; Ji, 2019)</td><td>75.01</td><td>48.33</td><td>73.63</td><td>66.12</td><td>71.12</td></tr><tr><td>SAGPool (Lee et al., 2019)</td><td>76.45</td><td>-</td><td>71.86</td><td>67.86</td><td>-</td></tr><tr><td>DiffPool (Ying et al., 2018)</td><td>80.64</td><td>62.53</td><td>76.25</td><td>78.86</td><td>75.48</td></tr><tr><td>MxPool (Ours)</td><td>92.10</td><td>66.90</td><td>77.21</td><td>82.21</td><td>73.44</td></tr><tr><td colspan="6">gPool (Gao &amp; Ji, 2019) is a recently proposed graph pooling method. It achieves pooling operation</td></tr><tr><td colspan="6">by adaptively selecting some nodes to form a smaller graph based on their scalar projection values</td></tr><tr><td>on a trainable projection vector.</td><td/><td/><td/><td/><td/></tr></table>

Effect of multiplex convolution/pooling. GraphSAGE) with different sets of hyperparameters are used to learn node representations. The node embedding size, as a hyperparameter in GraphSAGE, plays an important role in determining the quality of node representation. We vary the node embedding sizes in different GraphSAGE networks. On the other hand, multiple graph pooling networks (i.e., DiffPool) with different sets of hyperparameters are used to coarsen graphs. The compression ratio, as a hyperparameter in DiffPool, plays an important role in determining the quality of graph representation. We vary the compression ratios in different DiffPool networks.

Table content: <table><tr><td/><td>Variations</td><td colspan="5">D&amp;D ENZYMES PROTEINS NCI109 COLLAB</td></tr><tr><td/><td>c 1  *  p 1</td><td>80.01</td><td>62.17</td><td>75.48</td><td>80.07</td><td>71.31</td></tr><tr><td>SCSP</td><td>c 2  *  p 1</td><td>79.33</td><td>59.85</td><td>74.47</td><td>80.10</td><td>71.33</td></tr><tr><td/><td>c 3  *  p 1</td><td>78.75</td><td>60.32</td><td>75.14</td><td>78.49</td><td>71.14</td></tr><tr><td>MCSP</td><td>[c 1 |c 2 |c 3 ]  *  p 1</td><td>88.60</td><td>63.01</td><td>75.57</td><td>81.43</td><td>72.23</td></tr><tr><td/><td>c 1  *  p 1</td><td>80.01</td><td>60.30</td><td>75.48</td><td>80.07</td><td>71.31</td></tr><tr><td>SCSP</td><td>c 1  *  p 2</td><td>78.64</td><td>56.12</td><td>75.96</td><td>78.47</td><td>71.78</td></tr><tr><td/><td>c 1  *  p 3</td><td>78.79</td><td>61.22</td><td>74.52</td><td>78.95</td><td>71.02</td></tr><tr><td>SCMP</td><td>c 1  *  [p 1 |p 2 |p 3 ]</td><td>87.50</td><td>61.85</td><td>76.01</td><td>78.47</td><td>72.89</td></tr><tr><td colspan="3">MCMP [c 1 |c 2 |c 3 ]  *  [p 1 |p 2 |p 3 ] 92.10</td><td>66.90</td><td>77.21</td><td>82.21</td><td>73.44</td></tr><tr><td>(i.e.,</td><td/><td/><td/><td/><td/><td/></tr></table>

Peer review (iclr2020):
Strengths: -- The paper is well written and easy to follow -- Learning graph representation learning is a very important problem -- The performance of the proposed approach are strong on the existing data sets Weakness -- the novelty of the proposed method is marginal -- Some real-case study on why the model works are not presented. -- The data sets used in the experiments are too small This paper studied learning the hierarchical representation of graphs. Comparing to the previous work DiffPool, the author proposed to use multiple node representations and multiple pooling functions. Experimental results on a few data sets prove the effectiveness of the proposed approach. Overall, the paper is well written and easy to follow. Learning the hierarchical representation of graphs is an important and also interesting problem. However, I feel the novelty of the proposed method is marginal. And besides, though illustrated using artificial example in the introduction, it is not clear why the proposed method work in practice. Specifically, I have the following questions: (1) How does multiple convolutional method compared with just concatenating the weight matrix W_i, in other words, we can just use a much larger node embedding size. From equation (2) and (3), I feel these two are identical. The authors should explain this. (2) Similar concerns in the multiple pooling case. (3) It would be more convincing that the authors presented a few real cases to prove the effectiveness of the proposed approach instead of only using the artificial examples in introduction.