Graph-Preserving Grid Layout: A Simple Graph Drawing Method for Graph Classification using CNNs
Yecheng Lyu Xinming Huang Ziming Zhang























Graph-Preserving Grid Layout: 
A Simple Graph Drawing Method for Graph Classification using CNNs
    Yecheng Lyu1Work was done during an internship at MERL., Xinming Huang1 and Ziming Zhang2Corresponding author.

1Worcester Polytechnic Institute, 2Mitsubishi Electric Research Laboratories (MERL)



    
==========================================================================================================================================================================================================




	
	Graph convolutional networks (GCNs) suffer from the irregularity of graphs, while more widely-used convolutional neural networks (CNNs) benefit from regular grids. 
	To bridge the gap between GCN and CNN, in contrast to previous works on generalizing the basic operations in CNNs to graph data, in this paper we address the problem of how to project undirected graphs onto the grid in a principled way where CNNs can be used as backbone for geometric deep learning. To this end, inspired by the literature of graph drawing we propose a novel graph-preserving grid layout (GPGL), an integer programming that minimizes the topological loss on the grid. Technically we propose solving GPGL approximately using a regularized Kamada-Kawai algorithm, a well-known nonconvex optimization technique in graph drawing, with a vertex separation penalty that improves the rounding performance on top of the solutions from relaxation. 
	Using GPGL we can easily conduct data augmentation as every local minimum will lead to a grid layout for the same graph.   
	
	Together with the help of multi-scale maxout CNNs, we demonstrate the empirical success of our method for graph classification. 
	





§ INTRODUCTION

Graph convolutional networks (GCNs) <cit.> refer to the family of networks that generalize well-established convolutional neural networks (CNNs) to work on structured graphs. The irregularity of a graph, number of nodes and degree of each node, however, brings significant challenges in learning deep models based on graph data, especially from the perspectives of architecture design and computation. In general, a GCN has two operations to compute feature representations for the nodes in a graph, namely aggregation and transformation. That is, the feature representation of a node is computed as an aggregate of the feature representations of its neighbors before it is transformed by applying the weights and activation functions. To deal with graph irregularity the adjacency matrix is fed into the aggregation function to encode the topology. Often the weights in the transformation function are shared by all the nodes in the neighborhood to handle the node orderlessness in the convolution.

On the other hand, CNNs have gained the reputation from success in many research areas such as speech <cit.> and vision <cit.> due to high accuracy and high efficiency that allows millions of parameters to be trained well, thanks to the regularity of the grids leading to tensor representations. The grid topology is naturally inherent in the convolution with optimized implementation, and thus no adjacency matrix is needed. The nodes in each local neighborhood are well ordered by location, and thus sharing weights among nodes is unnecessary. 


r.3
	

	

		
    < g r a p h i c s >

		

		Illustration of two ways to handle graph data. The red path shows our methodology.
		
	

	


Motivation
Such key differences between graph convolution and spatial convolution make CNNs much easier and richer in deep architectures as well as being trained much more efficiently. Most of previous works in the literature such as GCNs, however, focus on the blue path in Fig. <ref> that aim to generalize the basic operations in CNNs and apply the new operations to graph data at the cost of, for instance, higher running time. Intuitively there also exists another way to handle graph data, shown as the red path in Fig. <ref>, that maps graphs onto grids so that CNNs can be applied directly to graph based applications. Such methods can easily inherit the benefits from CNNs such as computational efficiency. We notice, however, that there are few papers in the literature to explore this methodology for geometric deep learning (GDL). As a graph topology can be richer and more flexible than a grid, and often encode important message of the graph, how to preserve graph topology on the grid becomes a key challenge for such methods.

Therefore, in order to bridge the gap between GCN and CNN and in contrast to previous works on generalizing the basic operations in CNNs to graph input, in this paper we aim to address the following question: Can we use CNNs as backbone for GDL by projecting undirected graphs onto the grid in a principled way to preserve graph topology?











In fact, how to visualize structural information as graphs has been well studied in graph drawing, an area of mathematics and computer science combining methods from geometric graph theory and information visualization to derive 2D or 3D depictions of graphs with vertices and edges whose arrangement within a drawing affects its understandability, usability, fabrication cost, and aesthetics <cit.>. In the literature, the Kamada-Kawai (KK) algorithm <cit.> is one of the most widely-used undirected graph visualization techniques. In general, the KK algorithm defines an objective function that measures the energy of each graph layout, and searches for the (local) minimum. This often leads to a graph layout where adjacent nodes are near some pre-specified distance from each other, and non-adjacent nodes are well-spaced.




To the best of our knowledge, however, such graph drawing algorithms have never been explored for GDL. One possible reason is that graph drawing algorithms often work in continuous spaces, while our case requires discrete spaces (grid) where CNNs can be deployed. Overall, how to project graphs onto the grid with topology preservation for GDL is still elusive in the literature.



Contributions
To address the question above, in this paper we propose a novel graph-preserving grid layout (GPGL), an integer programming problem that minimizes the topological loss on the grid so that CNNs can be used for GDL on undirected graphs. Technically solving such a problem is very challenging because potentially one needs to solve a highly nonconvex optimization problem in a discrete space. We manage to do so by proposing a regularized KK method with a novel vertex separation penalty, followed by the rounding technique. As a result, our GPGL can manage to preserve the irregular structural information in a graph on the regular grid as graph layout, as illustrated in Fig. <ref>. 

In summary, our key contributions are twofold as follows:

	
  * We are the first, to the best of our knowledge, to explicitly explore the usage of graph drawing algorithms in the context of GDL, and accordingly propose a novel regularized Kamada-Kawai algorithm to project graphs onto the grid with minimum loss in topological information.
	
  * We demonstrate the empirical success of GPGL on graph classification, with the help of affine-invariant CNNs.





§ RELATED WORK

Graph Drawing & Network Embedding
Roughly speaking, graph drawing can be considered as a subdiscipline of network embedding <cit.> whose goal is to find a low dimensional representation of the network nodes in some metric space so that the given similarity (or distance) function is preserved as much as possible. In summary, graph drawing focuses on the 2D/3D visualization of graphs <cit.>, while network embedding emphasizes the learning of low dimensional graph representations. Despite the research goal, similar methodology has been applied to both areas. For instance, the KK algorithm <cit.> was proposed for graph visualization as a force-based layout system with advantages such as good-quality results and strong theoretical foundations, but suffering from high computational cost and poor local minima. Similarly <cit.> proposed a global geometric framework for network embedding to preserve the intrinsic geometry of the data as captured in the geodesic manifold distances between all pairs of data points. There are also some works on drawing graphs on lattice, <cit.>.

In contrast to graph drawing, our focus is to project an existing graph onto the grid with minimum topological loss so that CNNs can be deployed efficiently and effectively to handle graph data. In such a context of GDL, we are not aware of any work that utilizes the graph drawing algorithms to facilitate GDL, to the best of our knowledge.

Graph Synthesis & Generation
Methods in this field, <cit.>, often aim to learn a (sophisticated) generative model that reflects the properties of the training graphs. Recently, <cit.> proposed learning an encoder-decoder for the graph layout generation problem to systematically visualize a graph in diverse layouts using deep generative model. <cit.> proposed jointly learning the graph structure and the parameters of GCNs by approximately solving a bilevel program that learns a discrete probability distribution on the edges of the graph for classification problems.

In contrast to such methods above, our algorithm for GPGL is essentially a self-supervised learning algorithm that is performed for each individual graph and requires no training at all. Moreover, we focus on re-deploy each graph onto the grid as layout while preserving its topology. This procedure is separate from the training of CNNs later.




Geometric Deep Learning
In general GDL studies the extension of deep learning techniques to graph and manifold structured data (<cit.>). In particular in this paper we focus on graph data only. Broadly GDL methods can be categorized into spatial methods (<cit.>) and spectral methods (<cit.>). Some nice survey on this topic can be found in <cit.>.

<cit.> proposed a framework for learning convolutional neural networks by applying the convolution operations to the locally connected regions from graphs. We are different from such a work by applying CNNs to the grids where graphs are projected to with topology preservation.

<cit.> proposed an ad-hoc method to project graphs onto 2D grid and utilized CNNs for graph classification. Specifically each node is embedded into a high dimensional space, then mapped to 2D space by PCA, and finally quantized into grid. In contrast, we propose a principled and systematical way based on graph drawing, a nonconvex integer programming formulation, for mapping graphs onto 2D grid. Besides, our graph classification performance is much better than both works. On MUTAG and IMDB-B data sets we can achieve 90.42% and 74.9% test accuracy with 1.47% improvement over <cit.> and 4.5% improvement over <cit.>, respectively.









§ GRAPH-PRESERVING GRID LAYOUT





 §.§ Problem Setup

Let 𝒢=(𝒱, ℰ) be an undirected graph with a vertex set 𝒱 and an edge set ℰ⊆𝒱×𝒱, and s_ij≥1, ∀ i≠ j be the graph-theoretic distance such as shortest-path between two vertices v_i, v_j∈𝒱 on the graph that encodes the graph topology. 

Now we would like to learn a function f:𝒱→ℤ^2 to map the graph vertex set to a set of 2D integer coordinates on the grid so that the graph topology can be preserved as much as possible given a metric d:ℝ^2×ℝ^2→ℝ and a loss ℓ:ℝ×ℝ→ℝ. As a result, we are seeking for f to minimize the following objective:

    min_f∑_i≠ jℓ(d(f(v_i), f(v_j)), s_ij).

Now letting 𝐱_i=f(v_i)∈ℤ^2 as reparametrization, we can rewrite Eq. <ref> as the following integer programming problem:

    min_𝒳⊆ℤ^2∑_i≠ jℓ(d(𝐱_i, 𝐱_j), s_ij),

where the set 𝒳={𝐱_i} denotes the 2D grid layout of the graph, all the vertex coordinates on the 2D grid. 



Self-Supervision
Note that the problem in Eq. <ref> needs to be solved for each individual graph, which is related to self-supervision as a form of unsupervised learning where the data itself provides the supervision <cit.>. This property is beneficial for data augmentation, as every local minimum will lead to a grid layout for the same graph.



2D Grid Layout
In this paper we are interested in learning only 2D grid layouts for graphs, rather than higher dimensional grids (even 3D) where we expect that the layouts would be more compact in volume and would have larger variance in configuration, both bringing more challenges into training CNNs properly later. We confirm our hypothesis based on empirical observations. Besides, the implementation of 3D basic operations in CNNs such as convolution and pooling are often slower than 2D counterparts, and the operations beyond 3D are not available publicly. 



Relaxation & Rounding for Integer Programming
Integer programming is NP-complete and thus finding exact solutions is challenging, in general <cit.>. Relaxation and rounding is a widely used heuristic for solving integer programming due to its efficiency <cit.>, where the rounding operator is applied to the solution from the real-number relaxed problem as the solution for the integer programming. In this paper we employ this heuristic to learn 2D grid layouts. For simplicity, in the sequel we will only discuss how to solve the relaxation problem (before rounding).






 §.§ Regularized Kamada-Kawai Algorithm

In this paper we set ℓ and d in Eq. <ref> to the least-square loss and Euclidean distance to preserve topology, respectively. 

Kamada-Kawai Algorithm
The KK graph drawing algorithm <cit.> was designed for a (relaxed) problem in Eq. <ref> with a specific objective function as follows:

    min_𝒳⊆ℝ^2ℒ_KK = ∑_i≠ j1/2(d_ij/s_ij - 1)^2,

where d_ij=𝐱_i - 𝐱_j, ∀ (i,j) denotes the Euclidean distance between vertices v_i and v_j. Note that there is no regularization to control the distribution of nodes in 2D visualization. 

Fig. <ref> illustrates the problems using the KK algorithm when projecting the fully-connected graph onto 2D grid. Eventually KK learns a circular distribution with equal space among the vertices as in Fig. <ref>(a) to minimize the topology preserving loss in Eq. <ref>. When taking a close look at these 2D locations we find that after transformation all these locations are within the square area [0,1]×[0,1], leading to the square pattern in Fig. <ref>(b) after rounding. Such behavior totally makes sense to KK because it does not care about the grid layout but only the topology preserving loss. However, our goal is not only to preserve the topology but also to make graphs visible on the 2D grid in terms of vertices.

Vertex Separation Penalty
To this end, we propose a novel vertex separation penalty to regularize the vertex distribution on the grid. The intuition behind it is that when the minimum distance among all the vertex pairs is larger than a threshold, say 1, it will guarantee that after rounding every vertex will be mapped to a unique 2D location with no overlap. But when any distance is smaller than the threshold, it should be considered to enlarge the distance, otherwise, no penalty. Moreover, we expect that the penalties will grow faster than the change of distances and in such a way the vertices can be re-distributed more rapidly. Based on these considerations we propose the following regularizer:

    ℛ_sep = λ∑_i≠ jmax{0, α/d_ij - 1},

where α≥0, λ≥0 are two predefined constants. From the gradient of ℛ_sep an arbitrary 2D variable 𝐱_i, that is,

    ∂ℛ_sep/∂𝐱_i = -λ∑_i≠ j𝐱_i - 𝐱_j/d_ij^31_{d_ij<α}

where 1_{·} denotes the indicator function returning 1 if the condition is true, otherwise 0, we can clearly see that α as a threshold controls when penalties occur, and λ controls the trade-off between the loss and the regularization, leading to different step sizes in gradient based optimization.



Our Algorithm
With the help of our new regularization, we propose a regularized KK algorithm as listed in Alg. <ref>, which tries to minimize the following regularized KK loss:

    min_𝒳⊆ℤ^2ℒ_GPGL = ℒ_KK + ℛ_sep.


(1) Initialization:
Note that both KK and our algorithms are highly nonconvex, and thus good initialization is need to make both work well, convergence to good local minima. 

To this end, we first utilize the KK algorithm to generate a vertex distribution. To do so, we employ the implementation in the Python library NetworkX which uses a circular layout as initialization by default. As discussed above, KK has no control on the vertex distribution. This may lead to serious vertex loss problems in the 2D grid layout where some of vertices in the original graph merge together as a single vertex on the grid after rounding due to small distances. 

To overcome this problem, we introduce an optional step, rescaling, to enlarge the pairwise distances linearly. 
Intuitively this step “zooms” in the vertex distribution returned by KK when the minimum distance is smaller than the threshold but cannot be too small (controlled by parameter γ≥0). In this way not only such vertices are still distributed well, but also there will be enough space among the vertices to search for a good local minimum for our algorithm.

By taking the scaled solution as initialization, we minimize the regularized KK loss, where the KK objective is used to preserve the graph topology and the regularizer monitors the distances to prevent the vertex loss on the grid. 



(2) Topology Preservation with Regularization:
As we observe, the key challenge in topology preservation comes from the node degree, and the lower degree the easier for preservation. Since there are only 8 neighbors at most in the 2D grid layout, it will induce a penalty for a graph vertex whose degree is higher than 8. Fig. <ref> illustrates such a case where the original graph is full-connected with 32 vertices. With the help of our regularization, we manage to map this graph to a ball-like grid layout, as shown in Fig. <ref>(c) and (d). 

	An ideal 2D grid layout with no vertex loss for a full-connected graph with |𝒱| vertices is a ball-like shape with radius of ⌈ (|𝒱|/π)^1/2⌉ that minimizes Eq. <ref> with relaxation of the regularized Kamada-Kawai loss. Here ⌈·⌉ denotes the ceiling operation.



	Given the conditions in the proposition above, we have s_ij=1, d_ij≥ 1,  ∀ i≠ j and ℛ_sep=0. Without loss of generalization, we uniformly deploy the graph vertices in a circle and set the circular center A to a node on the 2D grid. Now imagine the gradient field over all the vertices as a sandglass centered at A where each vertex is a ball with a unit diameter. Then it is easy to see that by the “gravity” (gradient) all the vertices move towards the center A, and eventually are stabilized (as a local minimum) within an r-radius circle whose covering area should satisfy |𝒱|≤π r^2, r=⌈ (|𝒱|/π)^1/2⌉ as the smallest sufficient radius to cover all the vertices with guarantee. We now complete our proof.



Note that Fig. <ref>(d) exactly verifies Prop. <ref> with a radius r=⌈ (32/π)^1/2⌉=4. In summary, our algorithm can manage to preserve graph topology on the 2D grid even when the node degree is higher than 8.


(3) Computational Complexity: 
The KK algorithm has the computational complexity of, at least, O(|𝒱|^2) <cit.> that limits the usage of KK to medium-size graphs (50-500 vertices). Since our algorithm in Alg. <ref> is based on KK, it unfortunately inherits this limitation as well. To accelerate the computation for large-scale graphs, we potentially can adopt the strategy in multi-scale graph drawing algorithms such as <cit.>. However, such an extension is out of scope of this paper, and we will consider it in our future work.  




 §.§ Graph Classification

Data Augmentation
As mentioned in self-supervision, each local minimum from our regularized KK algorithm in Alg. <ref> will lead to a grid layout for the graph, while each minimum depends on its initialization. Therefore, to augment grid layout data from graphs, we do a random shuffle on the circular layout when applying Alg. <ref> to an individual graph. 

Grid-Layout based 3D Representation
Once a grid layout is generated, we first crop the layout with a sufficiently large fixed-size window (64× 64), and then associate each vertex feature vector from the graph with the projected node within the window. All the layouts are aligned to the top-left corner of the window. The rest of nodes in the window with no association of feature vectors are assigned to zero vectors. 

Once vertex loss occurs, we take an average, by default, of all the vertex feature vectors (average-pooling) and assign it to the grid node. We also compare average-pooling with max-pooling for merging vertices, and observe similar performance empirically in terms of classification.







Classifier: Multi-Scale Maxout CNNs (MSM-CNNs)
We apply CNNs to the 3D representations of graphs for classification. As we discussed above, once the node degree is higher than 8, the grid layout cannot fully preserve the topology, but rather tends to form a ball-like compact pattern with larger neighborhood. To capture such neighborhood information effectively, the kernel sizes in the 2D convolution need to vary. Therefore, the problem now boils down to a feature selection problem with convolutional kernels.

Considering these, here we propose using a multi-scale maxout CNN as illustrated in Fig. <ref>. We use consecutive convolutions with smaller kernels to approximate the convolutions with larger kernels. For instance, we use two 3×3 kernels to approximate a 5×5 kernel. The maxout <cit.> operation selects which scale per grid node is good for classification and outputs the corresponding features. Together with other CNN operations such as max-pooling, we can design deep networks, if necessary. 


Graph Label Prediction by Majority Voting
In our experiments we perform 10-fold leave-one-out testing. For simplicity we conduct data augmentation once on all the graphs. Therefore, even a test graph still has multiple grid layouts. By default we use the majority voting mechanism to predict the graph label based on all the predicted labels from its grid layouts. We also try to randomly sample a grid layout and utilize its label as the graph label. We find that statistically there is marginal difference between the two prediction mechanisms. In fact, we observe that the accuracy of graph prediction is very close to that of grid layout prediction.





§ EXPERIMENTS

Data Sets
We evaluate our method, graph-preserving grid layout + (multi-scale maxout) CNNs, on four medium-size benchmark data sets for graph classification, namely MUTAG, IMDB-B, IMDB-M and PROTEINS. Table <ref> summarizes some statistics of each data set. Note that the max node degree on each data set is at least 8, indicating that ball-like patterns as discussed in Prop. <ref> may occur, especially for IMDB-B and IMDB-M.



Implementation
By default, we set the parameters in Alg. <ref> as α=1.25, λ=1000. In this paper we do not use rescaling because we find that the initial KK solutions are sufficient to learn good grid layouts. We crop all the grid layouts to a fixed-size 64× 64 window.

Also by default, for the MSM-CNNs we utilize three consecutive 3×3 kernels in the MSM-Conv, and design a simple network of “MSM-Conv(64)→max-pooling→MSM-Conv(128)→max-pooling→MSM-Conv(256)→global-pooling→FC(256)→FC(128)” as hidden layers with ReLU activations, where FC denotes a fully connected layer and the numbers in the brackets denote the numbers of channels in each layer. We employ Adam <cit.> as our optimizer, and set batch size, learning rate, and dropout ratio to 10, 0.0001, and 0.3, respectively.




 §.§ Ablation Study


Effects of α, λ on Grid Layout and Classification

To understand their effects on grid layout generation, we visualize some results in Fig. <ref> using different combinations of α, λ. We can see that:

	
  * From Fig. <ref>(a)-(c), the diameters of grid layouts are 5×5, 6×6, 7×7 for α=1.00, 1.25, 1.50, respectively. This strongly indicates that a smaller α tends to lead to a more compact layout at the risk of losing vertices.
	
  * From Fig. <ref>(c)-(e), similarly the diameters of grid layouts are 5×5, 6×6, 6×6 for λ=200, 1000, 5000, respectively. This indicates that a smaller λ tends to lead to a more compact layout at the risk of losing vertices as well. In fact in Fig. <ref>(d) node 1 and node 5 are merged together. When λ is sufficiently large, the layout tends to be stable.

Such observations follow our intuition in designing Alg. <ref>, and occur across all the four benchmark data sets.

We also test the effects on classification performance. For instance, we generate 21x grid layouts using data augmentation on MUTAG, and list our results in Table <ref>. Clearly our default setting achieves the best test accuracy. It seems that for classification parameter α is more important. 





Vertex Loss, Graph Topology & Misclassification
To better understand the problem of vertex loss, we visualize some cases in Fig. <ref>. The reason for this behavior is due to the small distances among the vertices returned by Alg. <ref> that cannot survive from rounding. Unfortunately we do not observe a pattern on when such loss will happen. Note that our Alg. <ref> cannot avoid vertex loss with guarantee, and in fact the vertex loss ratio on each data set is very low, as shown in Table <ref>.





Further we test the relationship between vertex loss and misclassification, and list our results in Table <ref> where 𝒢_v.l., 𝒢_n.v.l., and 𝒢_mis. denote the sets of graphs with vertex loss, no vertex loss, and misclassification, respectively, ∩ denotes the intersection of two sets, |·| denotes the cardinality of the set, and the numbers in the brackets denote the numbers of grid layouts per graph in data augmentation. From this table, we can deduce that vertex loss cannot be not the key reason for misclassification, because it takes only tiny portion in misclassification and the ratios of misclassified graphs with/without vertex loss are very similar, indicating that misclassification more depends on the classifier rather than vertex loss.

Next we test the relationship between graph topology in terms of node degree and misclassification, and show our results in Fig. <ref>. As discussed before, a larger node degree is more difficult for preserving topology. In this test we would like to verify whether such topology loss introduces misclassification. Compared with the statistics in Table <ref>, it seems that topology loss does cause trouble in classification. One of the reasons may be that the variance of the grid layout for a vertex with larger node degree will be higher due to perturbation. Designing better CNNs will be one of our future works to improve the performance.

CNN based Classifier Comparison
We test the effectiveness of our MSM-CNNs, compared with (1×1)-kernel counterpart and ResNet-50 <cit.>, using the same augmented data. On MUTAG in terms of mean test accuracy, MSM-CNNs can achieve 89.34%, while (1×1)-kernel counterpart and ResNet-50 achieve 86.79% and 86.78%, respectively. Similar observations are made on the other data sets. Therefore, the feature selection mechanism seems very useful in graph classification with our grid layout algorithm.


r.5
	

	

		
    < g r a p h i c s >

		

		Running time at inference for GPGL and MSM-CNN.
		
	

	


Running Time
To verify the running time of our method, we show the inference time in Fig. <ref> for both GPGL and MSM-CNN, respectively. GPGL is optimized on an Intel Core i7-7700K CPU and MSM-CNN is run on a GTX 1080 GPU. We do not show the training time for MSM-CNN because it highly depends on the number of training samples as well, but should be linearly proportional to inference time, roughly speaking. As we see, the inference time for MSM-CNN is roughly the same, and much less than that for GPGL. The running time of GPGL on PROTEINS is the highest due to its largest average number of nodes among the four data sets, which is consistent with our complexity analysis. 



r.5
	

	

		
    < g r a p h i c s >

		

		Illustration of data augmentation on classification.
		
	

	


Effect of Data Augmentation using Grid Layouts on Classification
In order to train the deep classifiers well, the amount of training data is crucial. As shown in Alg. <ref>, our method can easily generate tons of grid layouts that effectively capture different characteristics in the graph. Given the memory limit, we demonstrate the test performance for data augmentation in Fig. <ref>, ranging from 1x to 101x with step 10x. As we see clearly, data augmentation can significantly boost the classification accuracy on MUTAG, and similar observations have been made for the other data sets.



 §.§ State-of-the-Art Comparison

To do a fair comparison for graph classification, we follow the standard routine, 10-fold cross-validation with random split. We directly cite the numbers from the leader board (as of 09/05/2019) at <https://paperswithcode.com/task/graph-classification> on each data set without reproducing these results. All the comparisons are summarized in Table <ref>, where the numbers in the brackets denote the numbers of grid layouts per graph in data augmentation.

In general, our method can match or even outperform the state-of-the-art on the four data sets, achieving two rank-1, one rank-2 and one rank-3 in terms of mean test accuracy. The small variances indicate the stability of our method. In summary, such results demonstrate the empirical success of our method on graph classification.

tabular
table





§ CONCLUSION

In this paper we answer the question positively that CNNs can be used directly for graph applications by projecting graphs onto grids properly. To this end, we propose a novel graph drawing problem, namely graph-preserving grid layout (GPGL), which is an integer programming to learn 2D grid layouts by minimizing topology loss. We propose a regularized Kamada-Kawai algorithm to solve the integer programming and a multi-scale maxout CNN to work with GPGL. We manage to demonstrate the success of our method on graph classification that matches or even outperforms the state-of-the-art on four benchmark data sets. As future work we are interested in applying this method to real-world problems such as point cloud classification.





aaai
	
  

	
