Year: 2019

Abstract:
Graphs are ubiquitous real-world data structures, and generative models that approximate distributions over graphs and derive new samples from them have significant importance. Among the known challenges in graph generation tasks, scalability handling of large graphs and datasets is one of the most important for practical applications. Recently, an increasing number of graph generative models have been proposed and have demonstrated impressive results. However, scalability is still an unresolved problem due to the complex generation process or difficulty in training parallelization. In this paper, we first define scalability from three different perspectives: number of nodes, data, and node/edge labels. Then, we propose GRAM, a generative model for graphs that is scalable in all three contexts, especially in training. We aim to achieve scalability by employing a novel graph attention mechanism, formulating the likelihood of graphs in a simple and general manner. Also, we apply two techniques to reduce computational complexity. Furthermore, we construct a unified and non-domain-specific evaluation metric in node/edge-labeled graph generation tasks by combining a graph kernel and Maximum Mean Discrepancy. Our experiments on synthetic and real-world graphs demonstrated the scalability of our models and their superior performance compared with baseline methods.

heading: 1 INTRODUCTION
text: Graphs are ubiquitous and fundamental data structures in the real world, appearing in various fields, such as social science, chemistry, and biology. Moreover, in applications such as drug discovery and network simulation, graph generative models that can approximate distributions over graphs on a specific domain and derive new samples from them are very important. Compared with generation tasks for images or natural language, graph generation tasks are significantly more difficult; this is due to the necessity of modeling complex local/global dependencies among nodes and edges as well as the intractable properties of graphs themselves, such as discreteness, variable number of nodes and edges, and uncertainty of node ordering.
Among the several challenges involved in graph generation tasks described above, scalability is one of the most important for applications in a wide range of real-world domains. In this paper, we define scalability from three perspectives: graph scalability, data scalability, and label scalability. Graph scalability denotes scalability to large graphs with many nodes within the limit of practical time/space complexity, especially in training. Data scalability denotes scalability to large datasets containing many data. Label scalability denotes scalability to graphs with many node/edge labels. Besides these, it is possible to consider other viewpoints, such as edge number, graph diameter, and the total number of nodes in a dataset. However, because these are closely related to the above three defined perspectives, we consider them as a mutually exclusive and collectively exhaustive division.
In recent years, an increasing number of graph generative models based on machine learning have been proposed. They have demonstrated great performances in several tasks, such as link prediction, molecular property optimization, and network structure optimization (Li et al., 2018; You et al., 2018b; Grover et al., 2018; Luo et al., 2018; You et al., 2018a; Liu et al., 2018; Simonovsky & Komodakis, 2018; Wang et al., 2017; Li et al., 2018). However, to the best of our knowledge, no proposed model is scalable in all three contexts. For example, DeepGMG (Li et al., 2018) can generate only small graphs, and GraphRNN (You et al., 2018b) cannot consider node/edge labels. Besides,
both models have weak compatibility with parallel training, which is key to efficient training on a large dataset.
In this work, we propose the Graph Generative Model with Graph Attention Mechanism (GRAM) for generating graphs that is scalable in all three contexts, especially during training. Given a set of graphs, our model approximates their distribution in an unsupervised manner. To achieve graph scalability, we employ an autoregressive sequential generation process that is flexible to variable nodes and edges, and formulate the likelihood of graphs in a simple manner to simplify the generation process. Besides, we apply two techniques to reduce computational cost: breadth-first search (BFS) and zeroing attention weights in edge estimation. Regarding data scalability, we apply a novel graph attention mechanism that simply extends the attention mechanism used in natural language processing (Vaswani et al., 2017) to graphs. This graph attention mechanism does not include sequentially dependent hidden states as the recurrent neural network (RNN) does, which improves the parallelizability of training significantly. Compared with other graph attention mechanisms (Veličković et al., 2018; Abu-El-Haija et al., 2018; Ishiguro et al., 2019), ours is architecturally simple, computationally lightweight, and general, i.e., its applicability is not limited to generation tasks. Finally, for label scalability, we formulate the likelihood of graphs assuming multiple node/edge labels. Also, we use graph convolution/attention layers, whose numbers of parameters do not depend directly on the number of labels.
Moreover, we introduce a unified non-domain-specific evaluation metric for generation tasks of node/edge-labeled graphs. Because such a method does not currently exist, prior works relied on domain-specific metrics or visual inspection, which made unified and objective evaluations difficult. Thus, we construct a unified evaluation metric that dispenses with domain-specific knowledge and considers not only the topology but also node/edge labels by combining a graph kernel and Maximum Mean Discrepancy (MMD) (Gretton et al., 2012). Although a similar statistical test based on MMD via a graph kernel was used for schema matching of protein graphs in Kriegel et al. (2006), to the best of our knowledge, this work is the first to use as an evaluation metric for graph generation tasks.
Our experiments on synthetic and real-world graphs demonstrated that our models can scale up to handle large graphs and datasets that previous methods had difficulty with; our models demonstrated superior results to those of baseline methods.
To summarize, the contributions of this work are as follows:
• We propose GRAM, a graph generative model that is scalable, especially in training. • We propose a novel graph attention mechanism that is general and architecturally simple
as a key portion of the generative model. • We define scalability in graph generation from three perspectives: number of nodes, data,
and labels. • We construct a unified non-domain-specific evaluation metric for node/edge-labeled graph
generation tasks by combining a graph kernel and MMD.

heading: 2 RELATED WORK
text: Although there are several traditional graph generative models (Erdös & Rényi, 1959; Albert & Barabási, 2002; Leskovec et al., 2010; Robins et al., 2007; Airoldi et al., 2009), we focus here on recent machine learning-based models, which have outperformed traditional models in various tasks.
In terms of their generation process, existing graph generative models can be classified into at least two types: tensor generation models and sequential generation models. Tensor generation models (Simonovsky & Komodakis, 2018; De Cao & Kipf, 2018; Grover et al., 2018) generate a graph by outputting tensors that correspond to the graph. These models are architecturally simple and easy to optimize for small graphs. However, they face difficulty in generating large graphs owing to the non-unique correspondence between a graph and tensors, limitations in the pre-defined maximum number of nodes, and the increasing number of parameters depending on the maximum graph size. In contrast, sequential generation models, such as DeepGMG (Li et al., 2018), GraphRNN(You et al., 2018b), generate graphs by adding nodes and edges one-by-one, which alleviates the above problems and generates larger graphs. To achieve graph scalability, we employ the latter. However,
to generate a graph with n nodes and m edges, DeepGMG requires at least O(mn2) operations because of its complex generation process. GraphRNN reduces this time complexity to O(nM) with a dataset-specific valueM by utilizing the BFS. However, it cannot handle node/edge labels, mainly because it omits the feature extraction process, and relies mainly on the information in the hidden states of the RNN. Moreover, these models include sequentially dependent hidden states, which make training parallelization difficult. In contrast, our model employs a graph attention mechanism without sequentially dependent hidden states. This improves the parallelizability of training significantly. Also, by applying two approximation methods, we reduce the complexity to almost a linear order of n while conducting a rich feature extraction. A comparison of our models’ and the baselines’ complexities is given in Table 2 in Section A.1.
As another division, there are unsupervised learning approaches and reinforcement learning approaches. Given samples of graphs, unsupervised learning models (Li et al., 2018; You et al., 2018b; Simonovsky & Komodakis, 2018; Grover et al., 2018) approximate the distribution of them in an unsupervised manner. Reinforcement learning models (Luo et al., 2018; You et al., 2018a; De Cao & Kipf, 2018; Liu et al., 2018; Li et al., 2018) learn to generate graphs to maximize a given return, such as QED (Bickerton et al., 2012). Although reinforcement learning approaches have demonstrated promising results on several tasks, such as molecular generation and network architecture optimization, we employ an unsupervised approach; this is because it is considered to be more advantageous when new samples that share certain properties with training samples are required or when the reward functions cannot be designed (e.g., a family of pharmaceutical molecules against a certain disease is known, but the mechanism by which they work is not entirely known).

heading: 3 PROPOSED METHOD
text: An outline of this section is as follows: In Section 3.1, we first describe notations and define the considered graph generation task. In Section 3.2, we formulate the likelihood of graphs. In Section 3.3, we present our proposed graph attention mechanism, which is the key portion of our model and is used in feature extraction and edge estimation. In Section 3.4, we present our scalable graph generative model, GRAM. We describe two techniques to reduce the computational cost of edge estimation: BFS in Section 3.5.1 and zeroing attention weights in Section 3.5.2. In Section 3.6, we describe the training and propose an evaluation metric.

heading: 3.1 NOTATIONS AND PROBLEM DEFINITION
text: In this work, we define a graph G = (V,E) as a data structure that consists of a node set V = {v1, ..., vn} and an edge set E = {ei,j |i, j ∈ {1, ..., n}}. For simplicity, we focus on undirected graphs. We assume nodes and edges are associated with node/edge labels and denote the number of them as a and b, respectively. For graph representation, we employ a tensor representation. Specifically, given node ordering π, we represent a pair of a graph and node ordering (G, π) as a pair of tensors (Xπ, Aπ). Note that we assume the existence of node ordering in graphs, and π is a permutation function over {1, ..., n}. Xπ ∈ {0, 1}n×a, whose i-th row is a one-hot vector corresponding to the label of vπ(i), stores information about nodes. Aπ ∈ {0, 1}n×n×b, whose (i, j)-th element is a one-hot vector corresponding to the label of eπ(i),π(j), stores information about edges. If no edge exists between vπ(i) and vπ(j), we replace it with a zero vector. An example is illustrated in Figure 3 in Section A.2. Note that (G, π) and (Xπ, Aπ) are in unique correspondence. Finally, for simplicity, we do not consider self-looping or multiple edges. A possible extension to self-looping edges would involve adding a step to estimate them. For multiple or directed edges, we can prepare additional labels that correspond to them. In the remainder of this paper, for clear notation, we assume π(i) = i and omit the superscript π.
The target graph generation task is as follows: given samples from a distribution of graphs p(G), approximate the distribution (p̂ ≈ p) such that we can derive new samples from it (G ∼ p̂(G)).

heading: 3.2 LIKELIHOOD FORMULATION OF GRAPHS
text: To approximate distributions over graphs in an autoregressive manner, we formulate the likelihood of a pair of a graph and node ordering (G, π) and decompose it into a product of conditional probabilities. Because (G, π) uniquely defines (X,A) and vice versa, we have p(G, π) = p(X,A), which
is decomposed into a product of conditional probabilities as p(X,A) = p(X1, A1,1) ∏n s=2 p(Xs|X<s, A<s,<s) ∏s−1 t=1 p(At,s|A<t,s, Xs, X<s, A<s,<s) (1) where A<s,<s ∈ Rs−1×s−1×b represents a partial tensor Ai,j (1 ≤ i, j < s), and other notations follow this. For simplicity, we omit the slice notation for the last dimension of each tensor. In addition, (X<s, A<s,<s) uniquely defines a subgraph of G, which we denote as G<s. With this formulation, the likelihood of a graph G is defined as marginal, p(G) = ∑ π p(G, π) = ∑ π p(X,A). Also, we represent (X<s, A<s,<s) as G<s in the following equations.
During training, given samples from p(G), our model approximates the joint probability p(X,A). More precisely, it approximates p(X,A) by approximating the conditional probabilities p(Xs|G<s) and p(At,s|A<t,s, Xs, G<s). As for p(X1, A1,1), we use a sampling distribution from the training data. Although the choice of π provides room for discussion, we adopt the BFS used in You et al. (2018b).
On inference, we sequentially sample Xs and At,s(s = 2, ..., n, t = 1, ..., s − 1) from the approximated distribution, and we get (X,A) when the EOS is output. This can be viewed as sampling from the approximated distribution (G, π) ∼ p̂(G, π). In particular, by focusing only on G, we can view it as sampling from the marginal G ∼ p̂(G).

heading: 3.3 GRAPH ATTENTION MECHANISM
text: The aim of employing a graph attention mechanism is to efficiently take in the information of distant nodes by attention. Our graph attention mechanism extends the attention mechanism used in natural language processing (Vaswani et al., 2017) to graphs. However, one of the significant differences between graphs and sentences is that we cannot define absolute coordinates in a graph, which makes it difficult to embed positional information in nodes as in Vaswani et al. (2017). To alleviate this problem, we focus on multi-head attention as in Vaswani et al. (2017), and we use relative positional information between nodes: we introduce bias terms in projection to subspaces, which are functions of the shortest path length between two nodes. The operation of graph attention is illustrated in Figures 5 and 6 in Section A.4.
Following Vaswani et al. (2017), we denote matrices into which n query, key, and value vectors are stacked as Q = (q1, ..., qn)T (∈ Rn×dQ),K = (k1, ...,kn)T (∈ Rn×dK ), and V = (v1, ...,vn)T (∈ Rn×dV ), respectively. Note that we use V to represent the value matrix, not node set. Also, we assume that the i-th row of each matrix corresponds to the feature vector of node vi. Note that the operation of graph attention is permutation invariant. Denoting the dimensions of the output vector and the subspace as dO and dS , respectively, the graph attention mechanism is defined as
GMultiHead(Q,K, V ) = Concat(head1, ...,headH)W O (∈ Rn×dO ) (2)
where headh = GAttention(Q,K, V ) (∈ Rn×dS ) (h = 1, ...,H) where H represents the number of projections to dS-dimensional subspaces. The operation of GAttention(·, ·, ·) is defined as
GAttention(Q,K, V ) = (o1, ...,on) T (∈ Rn×dS ) (3) where oi = ∑n j=1 (ci)j(W V vj + b V (vi, vj)) (∈ RdS ) (i = 1, ..., n) Each attention weight vector ci is calculated as ci = softmax(si) (∈ Rn) (i = 1, ..., n) (4)
where (si)j = dK − 12 (WQqi + b Q(vi, vj)) T (WKkj + b K(vi, vj)) (∈ R) (j = 1, ..., n) The parameters to be learned are four weight matrices –WQ(∈ RdS×dQ),WK(∈ RdS×dK ),WV (∈ RdS×dV ),WO(∈ RHdS×dO ) – and three bias terms – bQ, bK , bV (∈ RdS ). We used different parameters for each head.
To consider the geometric relation between two nodes, we used functions of the shortest path length between vi and vj as bQ(vi, vj), bK(vi, vj), and bV (vi, vj). Furthermore, because path length is discrete, we used different weight parameters for each path length. Examples of other possible approaches include using network flow or functional approximation. Specifically, setting bQ = bK = bV = 0 yields the original multi-head attention. As in Vaswani et al. (2017), we added a twolayer feedforward neural network (FNN), which is applied after the above operations. We denote these operations, including the FNN, as the graph attention mechanism in the following sections.
C3B EE E AC3B A G
hv(l 1)i<latexit sha1_base64="PDPZUpUhbA5/Olb6e0tyKpVmKOw=">AAAClHichVHLSsNAFD3G97NVQQQ3YqnUhWWigiIuBBFciVprBa0liaMO5kWSVjT0B/wBF+JCQUXc+wNu/AEX/QRxqeDGhTdpQLRY7zAzZ87cc+cMV7V14XqMVRqkxqbmlta29o7Oru6eWLy3b8O1io7Gs5qlW86mqrhcFybPesLT+abtcMVQdZ5TDxeC+1yJO66wzHXv2OZ5Q9k3xZ7QFI+oQrx3WzX8g3JB7PillD4uj5UL8QRLszCGa4EcgQSiWLHiD9jGLixoKMIAhwmPsA4FLo0tyGCwicvDJ84hJMJ7jjI6SFukLE4ZCrGHtO7TaStiTToHNd1QrdErOk2HlMNIsmd2x97YE7tnL+zzz1p+WCPwcky7WtVyuxA7Hcx8/KsyaPdw8K2q69nDHmZCr4K82yET/EKr6ksnZ2+Z2bWkP8qu2Cv5v2QV9kg/MEvv2vUqXzuv40clL0F75N/NqAUbE2l5Mj2xOpWYH40a1YYhjCBF3ZjGPJawgixVP8IFbnArDUhz0oK0WE2VGiJNP36EtPwFDWyWVQ==</latexit>
hv(l)i<latexit sha1_base64="ItQ/hJUNwv1JkBmXqaUf9KiLEOU=">AAACknichVG7TgJBFL2sL8QH+ChMbIgEgw0Z0ERDhaGxsOAhjwSQ7K4DTNhXdhcS3PAD/oAFlUYKY+8P2PgDFnyCscTExsK7yyZGiXg3u3PmzD13z+QImsQMk5Chh5uZnZtf8C76lpZXVv2BtfWCobZ1keZFVVL1ksAbVGIKzZvMlGhJ0ykvCxItCq2UfV7sUN1gqnJmdjValfmGwupM5E2kagF/RZCtZq/Gzq1ORNrr1QIhEiVOBSdBzAUhcCutBh6hAheggghtkIGCAiZiCXgw8ClDDAhoyFXBQk5HxJxzCj3wobaNXRQ7eGRb+G3gruyyCu7tmYajFvEvEr46KoMQJi/knozIM3kgr+Tzz1mWM8P20sVVGGupVvNfbeU+/lXJuJrQ/FZN9WxCHY4crwy9aw5j30Ic6zuX16NcIhu2dskteUP/N2RInvAGSuddHGRotj/Fj4Be7Hhiv8OYBIV4NLYfjWcOQsldNygvbMMORDCNQ0jCCaQh7yTWhzsYcJtcgjvmUuNWzuNqNuBHcadf74GV4w==</latexit>
Figure 2: l-th feature extraction block.

heading: 3.4 GRAM: SCALABLE GENERATIVE MODELS FOR GRAPHS
text: GRAM approximates a distribution over graphs in an autoregressive manner. It utilizes the graph attention mechanism to improve the parallelizability of training. The s-th step of the generation process is illustrated in Figure 1; a larger and more detailed version is given in Figure 4 in Section A.3. A detailed analysis of computational complexity is included in Section A.1.

heading: 3.4.1 MODEL OVERVIEW
text: In the following sections, we focus on the s-th step, i.e., the generation of vs and {e1,s, ..., es−1,s}. The architecture of GRAM consists of three networks: feature extractor, node estimator, and edge estimator. The feature extractor calculates node feature vectors and a graph feature vector by summing them. The node estimator predicts the label of the new node vs. The edge estimator predicts the labels of new edges {e1,s, ..., es−1,s} between previously generated nodes {v1, ..., vs−1} and the new node vs. In other words, the node estimator approximates p(Xs|G<s), and the edge estimator approximates p(At,s|A<t,s, Xs, G<s) in Equation 1.

heading: 3.4.2 FEATURE EXTRACTOR
text: Given a pair (X<s, A<s,<s), the feature extractor calculates s − 1 node feature vectors Hv = (hv1, ...,h v s−1)
T and a graph feature vector hG of the corresponding subgraph G<s. Here, hvi denotes the feature vector of node vi, and we use h v(l) i to represent the output vector of the l-th block. This consists of L feature extraction blocks and a graph pooling layer. In this work, we used L = 3.
A feature extraction block is composed of a graph convolution layer and a graph attention layer stacked in parallel, as illustrated in Figure 2. We aim to extract local information by graph convolution layers and global information by graph attention layers. Although there are various types of graph convolutions, we employed the one used in Johnson et al. (2018). 1 Roughly speaking, this convolutes the features of neighboring nodes and edges into each node and edge in a graph. A graph attention layer operates self-attention, where query/key/value vectors are all node feature vectors. To reduce computational cost, we restricted the range of attention to path length r. Also, to exploit low-level features, we stacked degree and clustering coefficients, which are non-domain-specific statistics in graphs, into each input node vector. Calculation of these graph statistics and BFS is required only once before training and is relatively fast compared with training time.
The graph pooling layer computes a graph feature vector hG by summing all node feature vectors in the subgraph. To improve its expressive power in aggregation, we used a gating network as in Li et al. (2018). Specifically, the operation in the graph pooling layer is defined as
hG = ∑s−1 i=1 σ(gpool(h v i ))h v i (5)
where gpool is a two-layer FNN, and σ is a sigmoid function.

heading: 3.4.3 NODE ESTIMATOR
text: The node estimator predicts the label of new node vs. More specifically, it predicts Xs from hG as
Xs = softmax(gNE(h G)) (∈ Ra+1) (6)
where gNE is a three-layer FNN, and the output dimension, including the EOS, is a + 1. We terminate the generation process when the EOS is output.
1Because Johnson et al. (2018) assume directed graphs as input, we ignore go in Figure 3 of that paper.

heading: 3.4.4 EDGE ESTIMATOR
text: The edge estimator predicts the labels of the new edges {e1,s, ..., es−1,s} between previously generated nodes {v1, ..., vs−1} and the new node vs. More precisely, it predicts At,s (t = 1, ..., s − 1) from hvt ,h G,hvs and previously predicted edge labels in this step as
At,s = softmax(gEE(h v t ,h G,hvs ,h e <t)) (∈ Rb+1) (t = 1, ..., s− 1) (7)
where hvs is the embedded vector of the predicted label of vs, i.e., Xs. The vector h e <t is calculated by a source-target attention in which the query vector is Concat(hvt ,h v s) and the key/value vectors are {Concat(hvτ ,hvs ,heτ,s)|τ = 1, ..., t − 1}, where heτ,s is an embedded vector of the predicted label of eτ,s, i.e., Aτ,s. Thereby, we aim to express the dependency on A<t,s in Equation 1. The operation is illustrated in Figure 6 in Section A.4. We use a three-layer FNN as gEE , where the output dimension is b+1, including the “no edge” label. When the “no edge” label is output, we do not add an edge and we set At,s = 0.

heading: 3.5 REDUCING COMPUTATIONAL COMPLEXITY IN EDGE ESTIMATION
text: To generate a graph with n nodes, the edge estimation process requires O(n) operations for one edge, resulting in O(n2) operations for one step and O(n3) operations in total. This is a significant obstacle to achieving graph scalability. Here, we present two methods to reduce complexity in edge estimation: BFS and zeroing attention weights; these can be combined independently.

heading: 3.5.1 COMPLEXITY REDUCTION VIA BREADTH FRIST SEARCH
text: As in You et al. (2018b), we utilize the BFS node ordering, but our implementation gives a stricter upper bound. More precisely, when estimating new edge et,s (t = 1, ..., s − 1), nodes that can be connected to the new node vs are restricted to “frontier nodes” Vf = {vτ |min({i|vi is connected to vs−1}) ≤ τ ≤ s − 1} under π = BFS . With this property, we need only consider Vf instead of the whole {v1, ..., vs−1} when estimating et,s. This reduces the complexity of edge estimation to O(nβ2), where β = |Vf |. A proof and example are included in Section A.5. Finally, we denote this variant as GRAM-B.

heading: 3.5.2 COMPLEXITY REDUCTION VIA ATTENTION WEIGHTS ZEROING
text: As another method, we use an approximation inspired by empirical observation. Specifically, our inspection of each attention weight during estimation of new edge et,s (t = 1, ..., s−1) revealed that the nodes predicted to have no connection to vs (i.e., Vnoedge = {vτ |Aτ,s = 0, τ = 1, ..., t−1}) have near-zero weights, while the nodes predicted to have connection (i.e., Vhaveedge = {vτ |Aτ,s 6= 0, τ = 1, ..., t− 1}) have larger weights. This suggests that among {v1, ..., vt−1}, Vhaveedge are important to predict the new edge et,s, while Vnoedge are not. Hence, we deterministically set the weights of the latter to zero, which means we do not consider them in graph attention. With this approximation, the complexity is reduced to O(n2α), where α = |Vhaveedge|. In addition, because α ≤ deg(vs) holds, we can assume that α n when deg(vs) n, which is often the case in many real-world graphs. A more detailed discussion and an example are included in Section A.6. Finally, we denote this variant as GRAM-A and the combination of the two as GRAM-AB, which has complexityO(nαβ).

heading: 3.6 TRAINING AND EVALUATION
text: The loss function is the negative logarithm of Equation 1, and the training is done in the usual autoregressive manner. In particular, for one graph, forward/backward propagation of n node estimations and at most n(n−1)/2 edge estimations can be processed parallelly (i.e., inO(1) sequential operations) by using ground-truth labels and proper masking.
To evaluate the quality of generation, evaluation metrics based on MMD with graph statistics were used in You et al. (2018b). However, these metrics cannot consider node/edge labels, and it is difficult to determine which one is important or not. Therefore, we construct a unified evaluation metric GK-MMD that can consider not only topology but also node/edge labels by combining a graph kernel and MMD.
MMD is a test statistic to determine whether two sets of samples from the distribution p and q are derived from the same distribution (i.e., whether p = q). When its function class F is a unit ball in a reproducing kernel Hilbert space (RKHS)H, we can derive the squared MMD as
MMD2[F , p, q] = Ex,x′∼p[k(x, x′)]− 2Ex∼p,y∼q[k(x, y)] + Ey,y′∼q[k(y, y′)] (8) where k(·, ·) is the associated kernel function (Gretton et al., 2012). Graph kernels are kernel functions over graphs, and we used the neighborhood subgraph pairwise distance kernel (NSPDK) (Costa & Grave, 2010), which measures the similarity of two graphs by matching pairs of subgraphs with different radii and distances. Because NSPDK is a positive-definite kernel (Costa & Grave, 2010), it follows that it defines a unique RKHS H (Aronszajn, 1950). This allows us to calculate the squared MMD using Equation 8.
Because NSPDK considers low/high-level topological features and node/edge labels, GK-MMD can be used as a unified evaluation metric for node/edge-labeled graph generation tasks.

heading: 4 EXPERIMENTS
text: We performed experiments on four types of synthetic graphs and three types of real-world graphs with various topologies, graph sizes, dataset sizes, and numbers of node/edge labels. We evaluated the quality of generation and the actual computational cost required.
As synthetic graphs, we used four types of random graphs: grid, lobster, community (Fortunato, 2010), and Barabási-Albert (B-A) (Barabási & Albert, 1999). We generated 700 graphs with numbers of nodes in the range 50 ≤ |V | ≤ 100. We split them into training/test/validation data at 500:100:100. To make the problem more realistic, we deterministically labeled nodes and edges according to their properties, such as degree or distance from backbone. Detailed configurations, including model-specific parameters and node/edge labeling, are described in Section A.7.
We used three types of real-world graphs: molecular, ego, and protein. For the molecular graphs, we used 250k samples from the ZINC database (Sterling & Irwin, 2015) provided by Kusner et al. (2017). The ego graphs are ego networks from the Citeseer networks (Sen et al., 2008). The protein graphs represent protein structures with amino acids as nodes (Dobson & Doig, 2003). For the ego and protein datasets, we used data provided by You et al. (2018b).
We compared our models with DeepGMG (Li et al., 2018), GraphRNN, and GraphRNN-S (You et al., 2018b) as recent deep learning-based baselines. We modified the GraphRNN and GraphRNNS models so that they can output multiple node/edge labels. Because we target the unsupervised learning graph generation task and most of the datasets we used are node/edge-labeled, we did not conduct a comparison with reinforcement learning-based methods or traditional models, which are incapable of handling node/edge labels, except for GraphRNN and its variant.
To evaluate the quality of generation, we calculated squared GK-MMD score between generated graphs and test graphs. We also used the squared MMD score of the three types of graph statistics used in You et al. (2018b): distributions of degree, clustering coefficient, and orbit count; however, these metrics do not consider node/edge labels. A lower MMD score indicates a better quality of approximation in terms of the given statistic. For the molecular graphs, we generated 10k samples and calculated the ratios of generated graphs that are valid as molecules (valid [%]), unique samples (unique [%]), and novel samples, i.e., valid, unique, and unseen in the training data (novel [%]). We also reported training time [hour].
The results are listed in Table 1. We did not train DeepGMG on the ego, protein and molecular datasets due to its impractical training time (estimated to take over 90 hours). Instead, for the molecular dataset, we used generated graphs provided by the author for evaluation. Although DeepGMG achieved a high valid/unique score and low GK-MMD score in the molecular dataset, it failed for larger graphs. This is likely because its feature extraction method is based only on graph convolution, which gives only local information, so it works well only on small graphs, such as those of molecules. Moreover, its training is slow due to its sequentially dependent hidden states.
GraphRNN and its variant achieved low topological MMD scores for simple topology graphs like grid. However, their performances were poor on other graphs with more complex topologies or rules. This is likely because they do not calculate node/edge features, which limited their expressive
power. In other words, the feature extraction process is inevitable for the generation of complex graphs.
In contrast, our models achieved overall lower MMD scores on most of the datasets, which means that the distance between the approximated distribution and the test set is relatively small in terms of topological and node/edge label features. Also, from the results on the molecular dataset, we can see that the generation is diverse while capturing the strict valence rule via unsupervised learning. This is likely due to the bias term of graph attention in edge estimation: it enables models to control the valence and type of rings. In terms of training time, there is a significant acceleration compared with the baselines. This is mainly owing to the graph attention mechanism, which reduces the number of sequential operations during training to almost constant and enables efficient parallelized training.
Besides, we can observe the impact of the two computational reduction techniques on the actual computational time. They were also more efficient in terms of memory usage, requiring less than half that of the original model. Surprisingly, although there is generally some trade-off between training speed and performance, GRAM-B performed better than the original model on the grid and ego datasets, and GRAM-A performed better on the molecular dataset. This is likely because each approximated model has its own strong topology for which both performance is boosted and computational cost is reduced. On average, the proposed models performed better on large graphs. More detailed discussions are included in Sections A.5 and A.6.
From the above results, we can see the scalability of our models for large graphs and datasets and multiple node/edge labels, which the baseline methods have difficulty in handling. Note that although our approximated models have some trade-off between performance and training speed, they still achieved superior or competitive results over the baselines in most cases. Also, we found an interesting correlation between GK-MMD score and topological MMD scores or visual similarity, which supports the validity of this metric. The detailed setting of the experiments, additional results, visualization, and an ablation study are included in Section A.7.

heading: 5 CONCLUSION
text: In this work, we tackled the problem of scalability as it is one of the most important challenges in graph generation tasks. We first defined scalability from three perspectives, and then we proposed a scalable graph generative model named GRAM along with some variants. Also, we proposed a novel graph attention mechanism as a key portion of the model and constructed GK-MMD as a unified evaluation metric for node/edge-labeled graph generation tasks. In an experiment using synthetic and real-world graphs, we verified the scalability and superior performances of our models.

heading: A APPENDIX

heading: A.1 COMPLEXITY ANALYSIS
text: In this section, we compare the computational complexity of the training of our models with that of existing models. Following Vaswani et al. (2017), we consider two factors: total computational complexity and minimum sequential operations with parallelization. Note that we assume all matrixvector products can be computed in constant time. Table 2 summarizes the results.
To generate a graph with n nodes andm edges, DeepGMG (Li et al., 2018) requires at leastO(mn2) operations. Because the initialization of the state of the new node depends on the state in the previous step, DeepGMG’s minimum required sequential operations isO(n2). On the other hand, GraphRNN (You et al., 2018b) requires O(nM) operations with a dataset-specific constant value M , utilizing the properties of the BFS and relying mainly on the hidden states of the RNN. However, its minimum number of sequential operations is O(n +M) because of the sequential dependency of the hidden states of the RNN; moreover, it cannot generate node/edge-labeled graphs.
Next, we evaluate GRAM and its variants. We denote the average number of nodes/edges within distance r of one node as Nr/Mr and reuse the α and β defined in Section 3.5.
In one step, the feature extractor requiresO(m+ nNr) operations, considering a graph convolution layer requires O(m), and a graph attention layer requires O(nNr). However, comparing the node features in G<s with those in G<s+1(= Gs ∪ vs ∪ {e1,s, ..., es−1,s}), only nodes within distance rL of vs change their features. Utilizing this property, we conduct feature extraction only for rLneighboring nodes of the previously added node and reuse features for the other nodes, by which the number of feature extraction operations is reduced to O(n(MrL +NrLNr)). Also, the node estimator requires O(n) operations in total. In edge estimation, GRAM requires O(n3) operations, GRAM-B requires O(nβ2), GRAM-A requires O(n2α), and GRAM-AB requires O(nαβ). Therefore, the total complexity of GRAM is O(n3 + n(MrL + NrLNr)), that of GRAM-B is O(nβ2+n(MrL+NrLNr)), that of GRAM-A isO(n2α+n(MrL+NrLNr)), and that of GRAMAB isO(nαβ+n(MrL+NrLNr)). Note that all the estimation operations of the node estimator and the edge estimator can be parallelized in training because our model has no sequentially dependent hidden states like the RNN does.
From the above analysis, we can see that our models require fewer operations than DeepGMG when Nr n holds, which is the often case, while keeping rich feature extraction. In addition, assuming NrL and MrL are nearly constant and sufficiently smaller than n and m, respectively, the total complexities of GRAM-B and GRAM-AB can be regarded as almost linear in n, which is competitive with GraphRNN, but ours keep the feature extraction. More importantly, all estimation operations can be parallelized, which facilitates training using multiple computing nodes. Therefore, we can expect graph scalability and data scalability of our models. We also expect label scalability because our models are flexible to a variable number of labels by modifying only the dimensions of the input and output layers.

heading: A.2 EXAMPLE OF TENSOR REPRESENTATION
text: An example of tensor representation is illustrated in Figure 3.
2EAS QE 1WSQACSOQ
2EAS QE 1WSQACSION .LOCK
3QAP OOLING
6 ( 6INEAQ (
6INEAQ
3QAP -SSENSION
8ODE 1 SIMASOQ 1DGE 1 SIMASOQ
X<s <latexit sha1_base64="bVAntZpXacloJbZiF87QeGIXyS4=">AAACh3ichVG7SgNBFD2uz/iM2gg2wZBgFWdVVMQiYmOp0TwgSthdJ3F1X+xOArr4A1Z2olYKFmLvD9j4AxZ+glgq2Fh4d7MgKsY7zMyZM/fcOcNVHUP3BGNPbVJ7R2dXd0+st69/YHAoPjxS8Oy6q/G8Zhu2W1IVjxu6xfNCFwYvOS5XTNXgRXV/JbgvNrjr6ba1KQ4cvm0qNUuv6poiiCqUKv6Sd1SJJ1mGhZH4DeQIJBHFmh2/wxZ2YENDHSY4LAjCBhR4NMqQweAQtw2fOJeQHt5zHKGXtHXK4pShELtPa41O5Yi16BzU9EK1Rq8YNF1SJpBij+yGvbIHdsue2ceftfywRuDlgHa1qeVOZeh4bOP9X5VJu8Dul6qlZ4EqFkKvOnl3Qib4hdbUNw5PXzcWcyk/za7YC/m/ZE/snn5gNd6063Weu2jhRyUvQXvkn834DQrTGXkmM70+m8ymo0b1YBwTmKRuzCOLVawhT9X3cIIznEsxaUqakxaaqVJbpBnFt5CWPwGIvJHa</latexit>
A<s,<s <latexit sha1_base64="U8rnKSXMfTfWuWlvWTXXzVwrHzo=">AAACi3ichVHLSsNAFD2Nr1pfVTeCm2JRXEiZtIJSulBEcGmrtcUHJYnTGkyTkEwLNfgDrgUXoqDgQtz7A278ARd+grhUcOPCmzQgKuodZubMmXvunOGqtqG7grHHiNTR2dXdE+2N9fUPDA7Fh0c2XKvhaLyoWYbllFXF5YZu8qLQhcHLtsOVumrwkrq/5N+XmtxxdctcFy2b79SVmqlXdU0RRG0uVrycO5PIuYeVeJKlWBCJn0AOQRJhrFrxW2xjFxY0NFAHhwlB2IACl8YWZDDYxO3AI84hpAf3HIeIkbZBWZwyFGL3aa3RaStkTTr7Nd1ArdErBk2HlAlMsgd2zV7YPbthT+z911peUMP30qJdbWu5XRk6Glt7+1dVp11g71P1p2eBKuYDrzp5twPG/4XW1jcPTl7WsoVJb4pdsmfyf8Ee2R39wGy+ald5Xjj9w49KXvz2yN+b8RNspFNyJpXOzyYXpsJGRTGOCUxTN+awgBWsokjVTRzjDOfSgJSRslKunSpFQs0ovoS0/AEKfZLm</latexit>
hG <latexit sha1_base64="L9px52BokjMuITgF/gzFTR8DFRM=">AAACiXichVE9T8JQFL3ULwQV1MXEhUggTuQVTSRMJAw68iEfCSBp6wNf6FfaQoINf8DRxQEXTRyMu3/AxT/gwE8wjpi4OHhbmhgl4m3ad95599yelyPqMjMtQkY+bm5+YXHJvxwIrqyuhcLrG2VT6xoSLUmarBlVUTCpzFRaspgl06puUEERZVoRO1nnvNKjhsk09djq67ShCG2VtZgkWEhV66Jinw1ODpvhKEkQtyLTgPdAFLzKaeFHqMMpaCBBFxSgoIKFWAYBTHxqwAMBHbkG2MgZiJh7TmEAAdR2sYtih4BsB79t3NU8VsW9M9N01RL+RcbXQGUEYuSF3JMxeSYP5JV8/jnLdmc4Xvq4ihMt1Zuhi63ix78qBVcLzr5VMz1b0IKU65Whd91lnFtIE33v/GpcTBdidpzckjf0f0NG5AlvoPbepbs8LQxn+BHRywDj4X+HMQ3KyQS/l0jm96OZuBeUH7ZhB3YxjQPIwBHkoOSmcAlDuOaCHM+luPSklfN5mk34UVz2C5ZlksA=</latexit>
H v <latexit sha1_base64="ai4OZ6UGzGHjJknAF/sURModL+Y=">AAACiXichVE9T8JQFL3ULwQV1MXEhUggTuQVTSRMJCyMfMhHAkja+sCGfqV9NEHCH3B0ccBFEwfj7h9w8Q848BOMIyYuDt6WJkaJeJv2nXfePbfn5YiGIluMkLGPW1hcWl7xrwaCa+sbofDmVsXSe6ZEy5Ku6GZNFCyqyBotM5kptGaYVFBFhVbFbtY5r9rUtGRdO2Z9gzZVoaPJbVkSGFK1hqgOcsMTuxWOkgRxKzILeA9Ewau8Hn6EBpyCDhL0QAUKGjDECghg4VMHHggYyDVhgJyJSHbPKQwhgNoedlHsEJDt4reDu7rHarh3ZlquWsK/KPiaqIxAjLyQezIhz+SBvJLPP2cN3BmOlz6u4lRLjVboYqf08a9KxZXB2bdqrmcGbUi5XmX0briMcwtpqrfPryaldDE2iJNb8ob+b8iYPOENNPtduivQ4miOHxG9DDEe/ncYs6CSTPAHiWThMJqJe0H5YRf2YB/TOIIM5CAPZTeFSxjBNRfkeC7FpaetnM/TbMOP4rJftceSzw==</latexit>
Xs <latexit sha1_base64="/5PMkspQDhXNb4Rg71BCcLTgQZU=">AAAChHichVG7SgNBFD2uGt8maiPYiCHBQsLEB4qFBGwsTWI0EEPYXSdxcF/sTgIa8gOCrRZWChZi7w/Y+AMWfoJYKthYeHezIBqMd5iZM2fuuXOGqzmG8CRjzz1Kb19/ZGBwaHhkdGw8GpuY3PXsuqvzgm4btlvUVI8bwuIFKaTBi47LVVMz+J52tOnf7zW46wnb2pHHDi+bas0SVaGrkqh8seJVYnGWYkHMdoJ0COIIY9uO3WMfB7Chow4THBYkYQMqPBolpMHgEFdGkziXkAjuOVoYJm2dsjhlqMQe0VqjUylkLTr7Nb1ArdMrBk2XlLNIsCd2y97YI7tjL+zzz1rNoIbv5Zh2ra3lTiV6Op3/+Fdl0i5x+K3q6lmiirXAqyDvTsD4v9Db+sbJxVt+PZdoJtk1eyX/V+yZPdAPrMa7fpPlucsufjTy0qL2pH83oxPsLqbSS6nF7HI8kwwbNYgZzGGeurGKDLawjQJVr+EM57hQIsqCsqSstFOVnlAzhR+hbHwBh2qQiA==</latexit>
At,s
(t = 1, ..., s 1) <latexit sha1_base64="AMUGLD8hgBNzxHNAHBMjtv14dKw=">AAACvHichVHLShxBFD3TRqMTo6NuBDeNg2KCNtWThQ9QRrJx6SOjgi1Dd085FtMvumsGtJkf8AdcuBADWYj7/IAEsoqrLPyEkKUBNy683dMoRmJuUVWnTt1z6xTXChwRScauc0rXq+6e1719+Tf9bwcGC0PDm5HfDG1esX3HD7ctM+KO8HhFCunw7SDkpms5fMtqfEzut1o8jITvfZIHAd91zbon9oRtSqKqhXnD4nXhxXVT7vPwfTu/XI3ltBq1VcNQp+SiPq1qmkbEjP4ub3Cv9pBZLRSZxtJQnwM9A0VkseoXvsJADT5sNOGCw4Mk7MBERGMHOhgC4nYRExcSEuk9Rxt50jYpi1OGSWyD1jqddjLWo3NSM0rVNr3i0AxJqWKC/WTn7IZ9ZxfsF7v7Z604rZF4OaDd6mh5UB08Gt24/a/KpV1i/1H1omeJPcylXgV5D1Im+YXd0bcOj282FtYn4kn2mf0m/2fsml3SD7zWH/vLGl8/ecGPRV6S9uh/N+M52Cxp+gettFYqliezRvViDOOYom7MoowVrKJC1U/xDT9wpSwpNaWhuJ1UJZdpRvAklNY9Gkqj1A==</latexit>
v1 <latexit sha1_base64="78UqvbKL7aS3qWsz7aWIjxZ7VcQ=">AAAChHichVG7SgNBFD1ZX/EdtRFsgiFiIWE2URQLEWws8zBRiCHsrmMc3Owuu5OAhvyAYKuFlYKF2PsDNv6ART5BLCPYWHizWRAV4x1m5syZe+6c4eqOKTzJWCuk9PUPDA6Fh0dGx8YnJiNT0wXPrrkGzxu2abt7uuZxU1g8L4U0+Z7jcq2qm3xXP97q3O/WuesJ29qRJw4vVbWKJQ6FoUmicvWyWo7EWIL5Ef0N1ADEEETajjxgHwewYaCGKjgsSMImNHg0ilDB4BBXQoM4l5Dw7zmaGCFtjbI4ZWjEHtNaoVMxYC06d2p6vtqgV0yaLimjiLNndsfa7Indsxf28Wethl+j4+WEdr2r5U558mw29/6vqkq7xNGXqqdniUOs+V4FeXd8pvMLo6uvn162c+vZeGOB3bBX8n/NWuyRfmDV34zbDM9e9fCjk5cmtUf92YzfoJBMqKlEMrMc21wIGhXGHOaxSN1YxSa2kUaeqldwjgtcKoPKkpJSVrqpSijQzOBbKBufO26QZA==</latexit>
v2 <latexit sha1_base64="sKz20eDfdwg/nXshhpQJvj1I/u8=">AAAChHichVG7SgNBFD1ZX/GZqI1gEwwRCwmTRFEsRLCxzMNEIYawu45xyGZ32Z0ENOQHBFstrBQsxN4fsPEHLPIJYhnBxsKbzYKoGO8wM2fO3HPnDFezDeFKxtoBZWBwaHgkODo2PjE5FQpPzxRcq+7oPK9bhuXsa6rLDWHyvBTS4Pu2w9WaZvA9rbrdvd9rcMcVlrkrT2xeqqkVUxwJXZVE5RrlZDkcZXHmReQ3SPggCj/SVvgBBziEBR111MBhQhI2oMKlUUQCDDZxJTSJcwgJ756jhTHS1imLU4ZKbJXWCp2KPmvSuVvT9dQ6vWLQdEgZQYw9szvWYU/snr2wjz9rNb0aXS8ntGs9LbfLobO53Pu/qhrtEsdfqr6eJY6w7nkV5N32mO4v9J6+cXrZyW1kY81FdsNeyf81a7NH+oHZeNNvMzx71cePRl5a1J7Ez2b8BoVkPJGKJzMr0a1Fv1FBzGMBS9SNNWxhB2nkqXoF57jApTKsLCspZbWXqgR8zSy+hbL5CT2MkGU=</latexit>
v3 <latexit sha1_base64="WUgWmUERR7O9NZbLMAYq1K4IYgI=">AAAChHichVG7SgNBFD1ZNcb4SNRGsAkGg4WESaIoFhKwsczDREEl7K6TuGRf7G4WYsgPCLamsFKwEHt/wMYfsMgniGUEGwtvNguiQb3DzJw5c8+dM1zJVBXbYawbEEZGx4LjoYnw5NT0TCQ6O1e2jYYl85JsqIZ1IIk2VxWdlxzFUfmBaXFRk1S+L9V3+vf7LrdsxdD3nKbJjzWxpitVRRYdoopuJVOJxlmSeREbBikfxOFHzog+4AgnMCCjAQ0cOhzCKkTYNA6RAoNJ3DFaxFmEFO+eo40waRuUxSlDJLZOa41Ohz6r07lf0/bUMr2i0rRIGcMye2Z3rMee2D17YR+/1mp5NfpemrRLAy03K5HzheL7vyqNdgenX6o/PTuoYtPzqpB302P6v5AHeves0ytuFZZbCXbDXsn/NeuyR/qB7r7Jt3leuPrDj0Re2tSe1M9mDINyOpnKJNP5tXg24TcqhEUsYYW6sYEsdpFDiarXcIFLdISgsCpkhPVBqhDwNfP4FsL2Jz+qkGY=</latexit>
v4 <latexit sha1_base64="k0M1nRmEarbbkjHIk8hMiyVGoHQ=">AAAChHichVG7SgNBFD1ZXzG+ojaCTTAkWEiYaESxEMHG0iRGBQ1hdx3j4L7YnSzE4A8ItlpYKViIvT9g4w9Y5BPEMoKNhTebBdGg3mFmzpy5584ZruYYwpOMNSNKT29f/0B0MDY0PDI6Fh+f2Pbsmqvzkm4btrurqR43hMVLUkiD7zouV03N4Dva8Xr7fsfnridsa0vWHV421aolDoWuSqKKfiVXiSdZhgWR6AbZECQRxqYdf8A+DmBDRw0mOCxIwgZUeDT2kAWDQ1wZDeJcQiK45zhFjLQ1yuKUoRJ7TGuVTnsha9G5XdML1Dq9YtB0SZlAij2zO9ZiT+yevbCPX2s1ghptL3XatY6WO5Wxs6ni+78qk3aJoy/Vn54lDrEceBXk3QmY9i/0jt4/uWwVVwqpRprdsFfyf82a7JF+YPlv+m2eF67+8KORl1NqT/ZnM7rB9nwmu5CZz+eSa+mwUVFMYwaz1I0lrGEDmyhR9SrOcYFLpV+ZUxaUxU6qEgk1k/gWyuonQciQZw==</latexit>
v5 <latexit sha1_base64="8lxhHjUM/ebdSUUPggJJgZiSgbk=">AAAChHichVG7SgNBFD1ZNcb4SNRGsBGDwULCbGJQLCRgYxmNSQQNYXcd45J9sbtZiCE/INiawkrBQuz9ARt/wCKfIJYKNhbebBZExXiHmTlz5p47Z7iypamOy1g3JAwNj4RHI2PR8YnJqVh8eqbkmA1b4UXF1Ex7X5YcrqkGL7qqq/F9y+aSLmu8LNe3evdlj9uOahp7btPiFV2qGeqxqkguUQWvmq3GEyzF/Fj4DcQAJBBE3ozf4xBHMKGgAR0cBlzCGiQ4NA4ggsEiroIWcTYh1b/naCNK2gZlccqQiK3TWqPTQcAadO7VdHy1Qq9oNG1SLmCJPbFb9soe2R17Zh9/1mr5NXpemrTLfS23qrGzucL7vyqddhcnX6qBnl0cY933qpJ3y2d6v1D6eu+081rY2F1qJdk1eyH/V6zLHugHhvem3Ozw3csBfmTy0qb2iD+b8RuU0ikxk0rvrCZyyaBREcxjEcvUjTXksI08ilS9hnNcoCOEhRUhI2T7qUIo0MziWwibn0PmkGg=</latexit>
G<s <latexit sha1_base64="bGJSD7Ecv4lLj5dx0sMiZEUGVrA=">AAACh3ichVFNLwNBGH6s7/oqLhIX0WicarYEEQfiwJFWS1JNs7umNexXdrdN2PgDTm6CE4mDuPsDLv6AQ3+COJK4OHh3u4nQ4J3MzDPPvM87z+RVbV24HmP1Fqm1rb2js6s71tPb1z8QHxzKu1bV0XhOs3TL2VYVl+vC5DlPeDrfth2uGKrOt9SDleB+q8YdV1jmpndo86KhVExRFpriEZVfLfmL7nEpnmApFsZYM5AjkEAU61b8HjvYhQUNVRjgMOER1qHApVGADAabuCJ84hxCIrznOEaMtFXK4pShEHtAa4VOhYg16RzUdEO1Rq/oNB1SjmGCPbFb9soe2R17Zh+/1vLDGoGXQ9rVhpbbpYGTkez7vyqDdg97X6o/PXsoYz70Ksi7HTLBL7SGvnZ09ppdyEz4SXbNXsj/FauzB/qBWXvTbjZ45vIPPyp5Cdoj/2xGM8inU/J0Kr0xk1hKRo3qwijGMUndmMMS1rCOHFXfxynOcSF1S1PSrDTfSJVaIs0wvoW0/AlkaZHJ</latexit>
vs <latexit sha1_base64="QFb6Bf0+zZtpZ6bJeHzv9yUQCxs=">AAAChHichVG7SgNBFD1ZNcb4SNRGsAmGiIWESaIoFhKwsczDPCBK2F0ncclmd9ndLMSQHxBsTWGlYCH2/oCNP2CRTxDLCDYW3mwWREW9w8ycOXPPnTNcyVAVy2as7xPGxif8k4Gp4PTM7FwoPL9QtPSWKfOCrKu6WZZEi6uKxgu2Yqu8bJhcbEoqL0mNveF9yeGmpejagd02+FFTrGtKTZFFm6i8U7Wq4SiLMzciP0HCA1F4kdHD9zjEMXTIaKEJDg02YRUiLBoVJMBgEHeEDnEmIcW95+giSNoWZXHKEIlt0FqnU8VjNToPa1quWqZXVJomKSOIsSd2ywbskd2xZ/b+a62OW2PopU27NNJyoxo6W8q//atq0m7j5FP1p2cbNWy7XhXybrjM8BfySO+c9gb5nVyss8qu2Qv5v2J99kA/0JxX+SbLc5d/+JHIS5fak/jejJ+gmIwnUvFkdiOaXvUaFcAyVrBG3dhCGvvIoEDV6zjHBXqCX1gXUsLmKFXweZpFfAlh9wPHKpCm</latexit>
e1,s <latexit sha1_base64="LF9Wd24obvh+6BFGKMKEg6vNdxQ=">AAACiXichVG7TgJBFL2sLwQV1MbEhkggFobMoomEioTGkoc8EiRkdx1wwr6yO5Ag4QcsbSyw0cTC2PsDNv6ABZ9gLDGxsfDusolRIt7N7pw5c8/dMzmyqTKbEzLyCXPzC4tL/uVAcGV1LRRe3yjbRsdSaEkxVMOqypJNVabTEmdcpVXTopImq7Qit7POeaVLLZsZ+jHvmbSuSS2dNZkicaSqtNEX9yL2oBGOkgRxKzINRA9EwaucEX6EEzgFAxTogAYUdOCIVZDAxqcGIhAwkatDHzkLEXPPKQwggNoOdlHskJBt47eFu5rH6rh3ZtquWsG/qPhaqIxAjLyQezImz+SBvJLPP2f13RmOlx6u8kRLzUboYqv48a9Kw5XD2bdqpmcOTUi5Xhl6N13GuYUy0XfPr8bFdCHWj5Nb8ob+b8iIPOEN9O67cpenheEMPzJ6ceIRf4cxDcrJhLifSOYPopm4F5QftmEHdjGNQ8jAEeSg5KZwCUO4FoKCKKSE9KRV8HmaTfhRQvYLfNCSPA==</latexit>
e2,s <latexit sha1_base64="aQ6+YgQXYv4Ljs/H0O+mOdQrrBo=">AAACinichVG7SgNBFD2u72eiNoLNYohYSJhdBV9NQAtLX/GBSthdJ3HIvtjdBHTJD9haWKiFgoXY+wM2/oBFPkEsI9hYeLNZEBX1DjNz5sw9d85wddcUfsBYrUVqbWvv6Ozq7unt6x9IJAeHNn2n7Bk8Zzim423rms9NYfNcIAKTb7se1yzd5Ft6abFxv1Xhni8ceyM4cvm+pRVtURCGFhC1w/OhOin7VTmfTLEMi0L+CZQYpBDHipO8xx4O4MBAGRY4bASETWjwaexCAYNL3D5C4jxCIrrnqKKHtGXK4pShEVuitUin3Zi16dyo6Udqg14xaXqklJFmT+yW1dkju2PP7P3XWmFUo+HliHa9qeVuPnEysv72r8qiPcDhp+pPzwEKmI28CvLuRkzjF0ZTXzk+q6/Pr6XDcXbNXsj/FauxB/qBXXk1blb52vkffnTyUqX2KN+b8RNsqhllKqOuTqey43GjujCKMUxQN2aQxTJWkKPqFk5xgUupT1KlOWmhmSq1xJphfAlp6QPq65Jn</latexit>
et,s <latexit sha1_base64="PnX49IElxES6D14QVKJX4huY/Z8=">AAACinichVG7SgNBFD2urxhfURvBZjEoFhJmo+CrEbSwVGN8oBJ210lc3Be7k0Bc8gO2FhZqoWAh9v6AjT9gkU8Qywg2Ft7dLIiKeoeZOXPmnjtnuJprGr5grN4itba1d3QmupLdPb19/amBwU3fKXs6z+uO6Xjbmupz07B5XhjC5Nuux1VLM/mWdrQU3m9VuOcbjr0hqi7ft9SSbRQNXRVE7fBCICZlvyYXUmmWYVHIP4ESgzTiWHVS99jDARzoKMMChw1B2IQKn8YuFDC4xO0jIM4jZET3HDUkSVumLE4ZKrFHtJbotBuzNp3Dmn6k1ukVk6ZHShlj7IndsgZ7ZHfsmb3/WiuIaoReqrRrTS13C/0nw7m3f1UW7QKHn6o/PQsUMRt5Nci7GzHhL/SmvnJ81sjNr48F4+yavZD/K1ZnD/QDu/Kq36zx9fM//GjkpUbtUb434yfYzGaUqUx2bTq9OB43KoERjGKCujGDRaxgFXmqbuEUF7iUeqSsNCctNFOlllgzhC8hLX8AeACSqQ==</latexit>
NO EDGE
, v⇡(1)
<latexit sha1_base64="j5C2yeXRTpl2itIWIkGEPgIhWV8=">AAACjHichVHLSsNAFL2Nr1q1rboR3BRLS92USS0oilAQxGUf9gFtKUkc69C8SNJALf0B9+JCUBRciHt/wI0/4KKfIC4ruHHhTRoQLdYbJnPmzD13zswVdZmZFiF9HzcxOTU9458NzM0vBEPhxaWSqbUNiRYlTdaMiiiYVGYqLVrMkmlFN6igiDIti609Z79sU8NkmnpodXRaV4Smyo6ZJFhIVe1Gt6azBL/eCzTCUZIkbkRGAe+BKHiR1cKPUIMj0ECCNihAQQULsQwCmPhVgQcCOnJ16CJnIGLuPoUeBFDbxiyKGQKyLfw3cVX1WBXXTk3TVUt4iozDQGUEYuSF3JMBeSYP5JV8/lmr69ZwvHRwFodaqjdCZyuFj39VCs4WnHyrxnq24Bi2XK8Mvesu49xCGurt04tBYTsf68bJLXlD/zekT57wBqr9Lt3laP5yjB8RvfSwPfzvZoyCUirJbyRTuXQ0E/ca5YdVWIMEdmMTMnAAWSi673kOV3DNBbk0t8PtDlM5n6dZhh/B7X8B17OTPA==</latexit>
v⇡(2) <latexit sha1_base64="VXuVOd/q8oS+tYZfJIk8/eUs80I=">AAACjHichVHLSsNAFL2Nr1q1rboR3BRLS92USS0oilAQxGUf9gFtKUkc69A0CUkaqKE/4F5cCIqCC3HvD7jxB1z0E8RlBTcuvEkDosV6w2TOnLnnzpm5oiYzwySk7+MmJqemZ/yzgbn5hWAovLhUMtSOLtGipMqqXhEFg8pMoUWTmTKtaDoV2qJMy2Jrz9kvW1Q3mKocml2N1ttCU2HHTBJMpKpWw65pLJFa7wUa4ShJEjcio4D3QBS8yKrhR6jBEaggQQfaQEEBE7EMAhj4VYEHAhpydbCR0xExd59CDwKo7WAWxQwB2Rb+m7iqeqyCa6em4aolPEXGoaMyAjHyQu7JgDyTB/JKPv+sZbs1HC9dnMWhlmqN0NlK4eNfVRtnE06+VWM9m3AMW65Xht41l3FuIQ311unFoLCdj9lxckve0P8N6ZMnvIFivUt3OZq/HONHRC89bA//uxmjoJRK8hvJVC4dzcS9RvlhFdYggd3YhAwcQBaK7nuewxVcc0Euze1wu8NUzudpluFHcPtf2dSTPQ==</latexit>
v⇡(3) <latexit sha1_base64="OdMauxp3/KZb2DoAkZxF5ho08Rw=">AAACjHichVHLSsNAFL2Nr1q1rboR3BRLS92USVtQFKEgiMs+7APaUpI4rUPTJCRpoIb+gHtxISgKLsS9P+DGH3DRTxCXFdy48DYNiBbrDZM5c+aeO2fmiprMDJOQvoebmp6ZnfPO+xYWl/yB4PJK0VA7ukQLkiqrelkUDCozhRZMZsq0rOlUaIsyLYmt/eF+yaK6wVTlyOxqtNYWmgprMEkwkapYdbuqsVhys+erB8MkTpwIjQPeBWFwI6MGH6EKx6CCBB1oAwUFTMQyCGDgVwEeCGjI1cBGTkfEnH0KPfChtoNZFDMEZFv4b+Kq4rIKroc1DUct4SkyDh2VIYiQF3JPBuSZPJBX8vlnLdupMfTSxVkcaalWD5yt5T/+VbVxNuHkWzXRswkN2Ha8MvSuOczwFtJIb51eDPI7uYgdJbfkDf3fkD55whso1rt0l6W5ywl+RPTSw/bwv5sxDoqJOJ+MJ7KpcDrqNsoL67ABMezGFqThEDJQcN7zHK7gmvNzKW6X2xulch5Xswo/gjv4Atv1kz4=</latexit>
v⇡(4) <latexit sha1_base64="ylAyKGCIjTE2N4+ONmBCqmAoESs=">AAACjHichVHLSsNAFL2Nr1q1rboR3BRLS92USS0oilAQxGUf9gFtKUkc69A0CUkaqKE/4F5cCIqCC3HvD7jxB1z0E8RlBTcuvEkDosV6w2TOnLnnzpm5oiYzwySk7+MmJqemZ/yzgbn5hWAovLhUMtSOLtGipMqqXhEFg8pMoUWTmTKtaDoV2qJMy2Jrz9kvW1Q3mKocml2N1ttCU2HHTBJMpKpWw65pLJFe7wUa4ShJEjcio4D3QBS8yKrhR6jBEaggQQfaQEEBE7EMAhj4VYEHAhpydbCR0xExd59CDwKo7WAWxQwB2Rb+m7iqeqyCa6em4aolPEXGoaMyAjHyQu7JgDyTB/JKPv+sZbs1HC9dnMWhlmqN0NlK4eNfVRtnE06+VWM9m3AMW65Xht41l3FuIQ311unFoLCdj9lxckve0P8N6ZMnvIFivUt3OZq/HONHRC89bA//uxmjoJRK8hvJVC4dzcS9RvlhFdYggd3YhAwcQBaK7nuewxVcc0Euze1wu8NUzudpluFHcPtf3haTPw==</latexit>
v⇡(5) <latexit sha1_base64="CApFJkL3R1/VKMhUZPMl4Bavx3Y=">AAACjHichVHLSsNAFL2Nr1q1rboR3BRLS92Uaa0oilAQxGUf9gFtKUmc1qFpEpI0UEN/wL24EBQFF+LeH3DjD7joJ4jLCm5ceJMGRIv1hsmcOXPPnTNzBVViukFI38NNTE5Nz3hnfXPzC/5AcHGpqCsdTaQFUZEUrSzwOpWYTAsGMyRaVjXKtwWJloTWvr1fMqmmM0U+MroqrbX5pswaTOQNpCpm3aqqLLa53vPVg2ESJ06ERkHCBWFwI6MEH6EKx6CACB1oAwUZDMQS8KDjV4EEEFCRq4GFnIaIOfsUeuBDbQezKGbwyLbw38RVxWVlXNs1dUct4ikSDg2VIYiQF3JPBuSZPJBX8vlnLcupYXvp4iwMtVStB85W8h//qto4G3DyrRrr2YAGbDteGXpXHca+hTjUm6cXg/xOLmJFyS15Q/83pE+e8Aay+S7eZWnucowfAb30sD2J380YBcVkPLERT2ZT4XTUbZQXVmENYtiNLUjDIWSg4LznOVzBNefnUtwutzdM5TyuZhl+BHfwBeA3k0A=</latexit>
X⇡ <latexit sha1_base64="MaeddPoXrRnbDiepd95/WwGDO1I=">AAACh3ichVG7SgNBFD1ZX4nPqI1gEwwRqziromIVsbFM1MRAfLC7jnF0X+xOAjHkB6zsRK0ULMTeH7DxByz8BLFUsLHwZrMgKuodZubMmXvunOHqril8ydhjRGlr7+jsisa6e3r7+gfig0MF36l4Bs8bjul4RV3zuSlsnpdCmrzoelyzdJOv6wdLzfv1Kvd84dhrsubyTUsr22JXGJokqlDc2nBFYjueZGkWROInUEOQRBhZJ36LDezAgYEKLHDYkIRNaPBplKCCwSVuE3XiPEIiuOdooJu0FcrilKERe0BrmU6lkLXp3KzpB2qDXjFpeqRMIMUe2DV7Yffshj2x919r1YMaTS812vWWlrvbA0cjq2//qizaJfY+VX96ltjFfOBVkHc3YJq/MFr66uHJy+rCSqo+zi7ZM/m/YI/sjn5gV1+NqxxfOf/Dj05eGtQe9XszfoLCVFqdTk/lZpKZ8bBRUYxiDBPUjTlksIws8lR9H8c4xZkSUyaVWWW+lapEQs0wvoSy+AHY8JGH</latexit>
A⇡ <latexit sha1_base64="TkfNoU0h8R+QL9GRDIKzOxX7cXg=">AAACh3ichVG7SgNBFD2u72eiNoJNMBis4qyKBivFxtJXopDEsLtOdMy+2N0EYvAHrOxErRQsxN4fsPEHLPIJYhnBxsK7mwXRYLzDzJw5c8+dM1zV1oXrMVbvkDq7unt6+/oHBoeGRyLR0bGMa5Udjac1S7ecPVVxuS5MnvaEp/M92+GKoep8Vy2t+fe7Fe64wjJ3vKrN84ZyaIqi0BSPqMzqfs4WsUI0zpIsiFgrkEMQRxgbVvQRORzAgoYyDHCY8AjrUODSyEIGg01cHjXiHEIiuOc4xQBpy5TFKUMhtkTrIZ2yIWvS2a/pBmqNXtFpOqSMYZq9sHvWYM/sgb2yzz9r1YIavpcq7WpTy+1C5Gxi++NflUG7h6NvVVvPHopIBV4FebcDxv+F1tRXTi4a28tb07UEu2Vv5P+G1dkT/cCsvGt3m3zruo0flbycUnvk381oBZm5pDyfnNtciK8kwkb1YRJTmKFuLGEF69hAmqof4xyXuJL6pVlpUUo1U6WOUDOOHyGtfgGny5Fw</latexit>
(X⇡, A⇡) <latexit sha1_base64="D9IDVszZdV2qJWvZTQgaOQenDEU=">AAACj3ichVHLSsNAFD3G97OtbgQ3xdJSQcq0CooLqbjRXavWFlorSRx1aJqEJC3U0h/wBxRcVXAh7v0BN/6ACz9BXCq4ceFNGhAt1hsm98yZe+6c4SqmJmyHsec+qX9gcGh4ZHRsfGJyKhAMTe/bRs1SeU41NMMqKLLNNaHznCMcjRdMi8tVReN5pbLpnufr3LKFoe85DZMfVOUTXRwLVXaIKscL5ZIpFsMbblo4DEZYgnkR7gZJH0TgR8YI3qOEIxhQUUMVHDocwhpk2PQVkQSDSdwBmsRZhIR3ztHCGGlrVMWpQia2Qv8T2hV9Vqe929P21CrdotGySBlGlD2xW/bGHtkde2Gff/Zqej1cLw3KSkfLzcPA+ezux7+qKmUHp9+qnp4dHGPV8yrIu+kx7ivUjr5+dvG2u7YTbcbYNXsl/232zB7oBXr9Xb3J8p2rHn4U8tKi8SR/D6Mb7KcSyaVEKrscScf8QY1gDvOI0zRWkMYWMshRdwuXaONaCkkr0rqU7pRKfb5mBj9C2v4CA9KUKA==</latexit> (G,⇡) <latexit sha1_base64="+j5oAkA3hw+/+ye1L3YVBeJ/4Jk=">AAACiXichVFNSwJRFL1OX6aVVpugjSSKQcgbCxJXgota+pEfoCIz09Mezhczo2DiH2jZpoVtClpE+/5Am/5AC39CtDRo06I740CUZHeYeeedd8+d8ziiLjPTImTk4ebmFxaXvMs+/8rqWiC4vlEytY4h0aKkyZpREQWTykylRYtZMq3oBhUUUaZlsZ2xz8tdaphMU0+snk7ritBSWZNJgoVUJXa0F6rpbLcRDJM4cSo0DXgXhMGtrBZ8hBqcggYSdEABCipYiGUQwMSnCjwQ0JGrQx85AxFzzikMwIfaDnZR7BCQbeO3hbuqy6q4t2eajlrCv8j4GqgMQYS8kHsyJs/kgbySzz9n9Z0ZtpceruJES/VG4GKr8PGvSsHVgrNv1UzPFjQh6Xhl6F13GPsW0kTfPb8aF1L5SD9Kbskb+r8hI/KEN1C779JdjuaHM/yI6GWA8fC/w5gGpUSc348ncgfhdNQNygvbsAMxTOMQ0nAMWSg6KVzCEK45P8dzSS41aeU8rmYTfhSX+QJCo5Gp</latexit>
G <latexit sha1_base64="RLxmrH7qcC2ZsjYEfQArXXhU3JU=">AAACg3ichVG7SgNBFD1ZXzE+ErURbIIhQRDCbBQUQRAstDSJeUAU2V0nccm+2N0ENOQHxFYtrBQsxN4fsPEHLPIJYhnBxsK7mwVRMd5hZs6cuefOGa5saarjMtYJCQODQ8Mj4dHI2PjEZDQ2NV10zIat8IJiaqZdliWHa6rBC67qarxs2VzSZY2X5Pqmd19qcttRTWPXPbb4vi7VDLWqKpJLVG4rfhBLsDTzI/4biAFIIIgdM/aAPRzChIIGdHAYcAlrkODQqEAEg0XcPlrE2YRU/56jjQhpG5TFKUMitk5rjU6VgDXo7NV0fLVCr2g0bVLGkWTP7I512RO7Zy/s489aLb+G5+WYdrmn5dZB9HQ2//6vSqfdxdGXqq9nF1Ws+l5V8m75jPcLpadvnlx282u5ZCvFbtgr+b9mHfZIPzCab8ptlueu+viRyUub2iP+bMZvUMykxaV0Jruc2EgFjQpjDvNYoG6sYAPb2EGBqldxhnNcCEPCopARlnupQijQzOBbCOufxCqPuw==</latexit>
n <latexit sha1_base64="8D6PwGjswecyWZbNxSj61oHAJwI=">AAACgnichVFNLwNRFD1GUfVVbCQ2jYaIRXOnJEQsJDaWqqpNEJkZDy+dr8xMm1TTP8CWWFiRWIi9P2DjD1j0J4gliY2F2+kkguC+vPfOO++e+87L1V1T+gFRs0PpjHV198R7E339A4NDyeGRTd+peIYoGI7peCVd84UpbVEIZGCKkusJzdJNUdTLK637YlV4vnTsjaDmih1LO7DlvjS0gKmcvZtMU4bCSP0EagTSiGLNSd5hG3twYKACCwI2AsYmNPg8tqCC4DK3gzpzHiMZ3gs0kGBthbMEZ2jMlnk94NNWxNp8btX0Q7XBr5g8PVamMEmPdEMv9EC39ETvv9aqhzVaXmq8622tcHeHjsfyb/+qLN4DHH6q/vQcYB8LoVfJ3t2Qaf3CaOurR+cv+cX1yfoUXdEz+7+kJt3zD+zqq3GdE+sXf/jR2UuD26N+b8ZPsJnNqLOZbG4uvTwVNSqOcUxgmrsxj2WsYg0Fri5wglOcKTFlRlGV2Xaq0hFpRvEllKUPrTePuA==</latexit>
a <latexit sha1_base64="FV+TMaRfqJ0ZS2Ukn8zjnBL+IMM=">AAACgnichVG7SgNBFD1Z4yu+ojaCTTAYxCLcjYIiFoKNpUnMA1Rkd53EJZvdZXcTiMEf0FaxsFKwEHt/wMYfsMgniGUEGwtvNguiYrzDzJw5c8+dM1zVNnTXI2qFpL5w/8Dg0HBkZHRsfCI6OZV3rZqjiZxmGZZTVBVXGLopcp7uGaJoO0KpqoYoqJXNzn2hLhxXt8wdr2GL/apSNvWSrikeU2nlIBqnJPkR+w3kAMQRxLYVfcAeDmFBQw1VCJjwGBtQ4PLYhQyCzdw+msw5jHT/XuAEEdbWOEtwhsJshdcyn3YD1uRzp6brqzV+xeDpsDKGeXqmO2rTE93TC338Wavp1+h4afCudrXCPpg4ncm+/6uq8u7h6EvV07OHElZ9rzp7t32m8wutq68fX7aza5n5ZoJu6JX9X1OLHvkHZv1Nu02LzFUPPyp7OeH2yD+b8RvkU0l5KZlKL8c3EkGjhjCLOSxwN1awgS1sI8fVBc5wjgspLC1KsrTUTZVCgWYa30Ja/wSRsY+r</latexit>
b <latexit sha1_base64="M+8LXWKvHAGRmHrfyZQJNfRUJeE=">AAACgnichVG7SgNBFD1Z4yu+ojaCTTAYxCLcjYIiFoKNpUnMA1Rkd53EJZvdZXcTiMEf0FaxsFKwEHt/wMYfsMgniGUEGwtvNguiYrzDzJw5c8+dM1zVNnTXI2qFpL5w/8Dg0HBkZHRsfCI6OZV3rZqjiZxmGZZTVBVXGLopcp7uGaJoO0KpqoYoqJXNzn2hLhxXt8wdr2GL/apSNvWSrikeU2n1IBqnJPkR+w3kAMQRxLYVfcAeDmFBQw1VCJjwGBtQ4PLYhQyCzdw+msw5jHT/XuAEEdbWOEtwhsJshdcyn3YD1uRzp6brqzV+xeDpsDKGeXqmO2rTE93TC338Wavp1+h4afCudrXCPpg4ncm+/6uq8u7h6EvV07OHElZ9rzp7t32m8wutq68fX7aza5n5ZoJu6JX9X1OLHvkHZv1Nu02LzFUPPyp7OeH2yD+b8RvkU0l5KZlKL8c3EkGjhjCLOSxwN1awgS1sI8fVBc5wjgspLC1KsrTUTZVCgWYa30Ja/wSTz4+s</latexit>
n <latexit sha1_base64="8D6PwGjswecyWZbNxSj61oHAJwI=">AAACgnichVFNLwNRFD1GUfVVbCQ2jYaIRXOnJEQsJDaWqqpNEJkZDy+dr8xMm1TTP8CWWFiRWIi9P2DjD1j0J4gliY2F2+kkguC+vPfOO++e+87L1V1T+gFRs0PpjHV198R7E339A4NDyeGRTd+peIYoGI7peCVd84UpbVEIZGCKkusJzdJNUdTLK637YlV4vnTsjaDmih1LO7DlvjS0gKmcvZtMU4bCSP0EagTSiGLNSd5hG3twYKACCwI2AsYmNPg8tqCC4DK3gzpzHiMZ3gs0kGBthbMEZ2jMlnk94NNWxNp8btX0Q7XBr5g8PVamMEmPdEMv9EC39ETvv9aqhzVaXmq8622tcHeHjsfyb/+qLN4DHH6q/vQcYB8LoVfJ3t2Qaf3CaOurR+cv+cX1yfoUXdEz+7+kJt3zD+zqq3GdE+sXf/jR2UuD26N+b8ZPsJnNqLOZbG4uvTwVNSqOcUxgmrsxj2WsYg0Fri5wglOcKTFlRlGV2Xaq0hFpRvEllKUPrTePuA==</latexit>
n <latexit sha1_base64="8D6PwGjswecyWZbNxSj61oHAJwI=">AAACgnichVFNLwNRFD1GUfVVbCQ2jYaIRXOnJEQsJDaWqqpNEJkZDy+dr8xMm1TTP8CWWFiRWIi9P2DjD1j0J4gliY2F2+kkguC+vPfOO++e+87L1V1T+gFRs0PpjHV198R7E339A4NDyeGRTd+peIYoGI7peCVd84UpbVEIZGCKkusJzdJNUdTLK637YlV4vnTsjaDmih1LO7DlvjS0gKmcvZtMU4bCSP0EagTSiGLNSd5hG3twYKACCwI2AsYmNPg8tqCC4DK3gzpzHiMZ3gs0kGBthbMEZ2jMlnk94NNWxNp8btX0Q7XBr5g8PVamMEmPdEMv9EC39ETvv9aqhzVaXmq8622tcHeHjsfyb/+qLN4DHH6q/vQcYB8LoVfJ3t2Qaf3CaOurR+cv+cX1yfoUXdEz+7+kJt3zD+zqq3GdE+sXf/jR2UuD26N+b8ZPsJnNqLOZbG4uvTwVNSqOcUxgmrsxj2WsYg0Fri5wglOcKTFlRlGV2Xaq0hFpRvEllKUPrTePuA==</latexit>
Figure 3: Example of tensor representation. n, a, and b denote the numbers of nodes, node labels, and edge labels, respectively. Xπ ∈ {0, 1}n×a, whose i-th row is a one-hot vector corresponding to the label of vπ(i), stores information about nodes. Aπ ∈ {0, 1}n×n×b, whose ( , j)-th element is a one-hot vector corresponding to the label of eπ(i),π(j), stores information about edges. If no edge exists between vπ(i) and vπ(j), we replace it with a zero vector. Note that (G, π) and (Xπ, Aπ) correspond uniquely.

heading: A.3 DETAILED MODEL PIPELINE
text: A detailed pipeline of GRAM is illustrated in Figure 4.
A.4 ILLUSTRATION OF GRAPH ATTENTION
The graph attention mechanism in feature extraction (self attention) is illustrated in Figure 5 and that in edge estimation (source target attention) is illustrated in Figure 6.
s−1 )
T ) (self
attention). For simplicity, we focused on one query/output vector and one subspace.

heading: A.5 GRAM-B: UTILIZING BREADTH-FIRST SEARCH NODE ORDERING
text: In this section, a brief and intuitive proof for the proposition in Section 3.5.1 is given along with additional discussion on how much the computational complexity is actually reduced by this approximation and its strong topology.

heading: A.5.1 PROOF
text: Consider the BFS tree in the left of Figure 7. Suppose there is at least one connection between the new node vs and the non-frontier nodes V \ Vf , where Vf = {vτ |min({i|vi is connected to vs−1}) ≤ τ ≤ s − 1} (right of Figure 7). Then, under the assumption of BFS node ordering, vs must be visited/generated before vs−1, which is a contradiction. Therefore, the nodes that can have connections between the new node vs are limited to the frontier nodes Vf (middle of Figure 7).
C 3 E CDE D 3C EC BADD A E A DADD A E A D

heading: A.5.2 DISCUSSION
text: The average values of β = |Vf | for each dataset are listed in Table 3. In both the synthetic and real-world graphs, we can see that β is relatively small compared to n (approximately 1/10 ∼ 1/3). Therefore, considering the results in Table 2, the average computational cost of GRAM-B is estimated to be approximately 1/100 ∼ 1/9 that of GRAM, which is a significant reduction. In the experiment, GRAM-B performed better than its original model on the grid and ego datasets. This is likely because these graphs have simple topologies and their BFS trees also have typical simple patterns. Therefore, restricting the range of edge estimation to the frontier nodes Vf made the problem easier for the model. Thus, we expect GRAM-B’s performance to be boosted when the topologies of the graphs and their BFS trees have simple patterns.

heading: A.6 GRAM-A: ZEROING ATTENTION WEIGHTS
text: Here, we provide an additional discussion on the actual computational complexity reduction by this approximation and its strong graph types. Figure 9 illustrates the attention weight zeroing in edge estimation.
Figure 8 shows the two distributions of attention weights in one step of edge estimation (i.e., in the calculation of he<t) on the grid dataset. The blue represents the distribution of weights for nodes that are predicted to have no connection to the new node vs (i.e., {vτ |Aπτ,s = 0, τ = 1, ..., t−1}), and the orange represents the distribution of weights for those predicted to have connection to the new node (i.e., {vτ |Aπτ,s 6= 0, τ = 1, ..., t − 1}). From this figure, we can see that the former distribution is sharper around zero compared with the latter, most of whose weights take near-zero values. Similar results were observed for the other datasets.
The average values of α for each dataset are listed in Talbe 3. In both the synthetic and real-world graphs, we can see that α is less than 4 and approximately 1/100 ∼ 1/20 of n. Thus, considering the results in Table 2, the computational cost of GRAM-A is estimated to be approximately 1/100 ∼ 1/20 that of GRAM on average, which is a dramatic reduction.
In the experiment, GRAM-A performed better than GRAM on the molecular dataset. This is likely because these graphs have strict rules or distinct patterns in incident edges to a node, such as the valence rule, and focusing only on the actual generated edges is both sufficient and makes the problem simpler. Thus, we expect that GRAM-A will demonstrate better performance when the graphs follow a certain strict rule on incident edges of their nodes.

heading: A.7 EXPERIMENTAL SETTING DETAILS

heading: A.7.1 DATASET CONFIGURATION
text: Here, the detailed configurations of the synthetic graphs are described. Samples from each synthetic graph dataset are illustrated in Figures 10, 11, 12, and 13 (color is best). Different color corresponds to different node/edge labels on each dataset.
Grid We used 2D grid graphs with the number of nodes in the range 50 ≤ |V | ≤ 100. Each node was labeled according to its degree, yielding 3 types of node labels: “corner”, “edge”, and
“inside”. Each edge was labeled according to its geometric direction, yielding 2 types of edge labels: “horizontal” and “vertical”.
Lobster We used lobster graphs with the number of nodes in the range 50 ≤ |V | ≤ 100. We set probability of adding an edge to the backbone p1 = 0.7, and probability of adding an edge one level beyond the backbone p2 = 0.3. Each node was labeled according to its distance from backbone, yielding 3 types of node labels: “leaf”, “branch”, and “backbone”. Each edge was labeled according to its incident nodes, yielding 2 types of edge labels: “leaf-branch” and “branch-backbone”.
Community We used 4-community graphs (Fortunato, 2010) with the number of nodes in the range 50 ≤ |V | ≤ 100. We set number of communities l = 4, number of nodes in one community k = |V |/4, probability of intra-connection pin = 0.23, and probability of inter-connection pout = 0.023. Each node was labeled according to the community it belongs to, yielding 4 types of node labels: “community1”, “community2”, “community3”, and “community4”. Each edge was labeled according to its incident nodes, yielding 2 types of edge labels: “intra-community connection” and “inter-community connection”.
B-A We used Barabási-Albert (B-A) graphs (Barabási & Albert, 1999) with the number of nodes in the range 50 ≤ |V | ≤ 100. We set number of edges to connect a new node and existing nodes as m = 4. Each node was labeled according to whether its degree falls in the top 50% or bottom 50%, yielding 2 types of node labels: “hub” and “exterior”. Each edge was labeled according to its incident nodes, yielding 3 types of edge labels: “hub-hub”, “hub-exterior”, and “exterior-exterior”.

heading: A.7.2 TRAINING CONFIGURATION
text: Here, we give details of the training configurations. We essentially used the default settings for the baseline methods.
For all datasets, DeepGMG was trained using a single GPU for 10 epochs with batch size 1 because its generation process is so complex that batch implementation is difficult.
GraphRNN and GraphRNN-S were trained using a single GPU for 96000 iterations with batch size 32. For the molecular dataset, considering its relatively large dataset size, we increased the number of iterations to 1536000.
For the convenience of implementation, we started the generation process from seed subgraphs with the number of nodes Nmin. For the synthetic graph datasets, we trained our models using a single GPU for 100 epochs with batch size 32, and we used r = 2 and Nmin = 10. For the molecular dataset, we trained our models using 2 GPUs for 20 epochs with batch size 256, and we used r = 7 andNmin = 5. For the ego dataset, we trained our models using 2 GPUs for 25 epochs, and we used r = 2 and Nmin = 12. We used batch size 4 for GRAM and batch size 8 for GRAM-A, GRAM-B, and GRAM-AB. For the protein dataset, we trained our models using 2 GPUs for 25 epochs, and we used r = 2 and Nmin = 12. We used batch size 4 for GRAM and batch size 32 for GRAM-A, GRAM-B, and GRAM-AB. Due to the code dependencies, Tesla P100 was used for DeepGMG, GraphRNN, and GraphRNN-S, and Tesla V100 was used for GRAM and its variants. Empirically, the choice between the two gave no significant difference in computation time for our cases.
In evaluation, we reported an average of 3 runs for each score. To calculate GK-MMD score for the molecular dataset, we used 100 samples from the generated graphs and 100 samples from the test set for fast evaluation. We reported an average of 10 runs.

heading: A.7.3 ADDITIONAL EXPERIMENT RESULT
text: The results on the lobster dataset are listed in Table 4. As on other datasets, GRAM and its variants demonstrated competitive results in terms of topological MMDs, and better performance in terms of GK-MMD.
In addition, considering that the molecular dataset is a subset of the druglike category in ZINC database (Sterling & Irwin, 2015), we reported the average QED scores (Bickerton et al., 2012) of the training samples and the generated samples. QED score measures the drug likeliness of the molecular.
Table 5 summarizes the results. We can see the generated molecular graphs of our models have higher QED compared with those of baselines, and near to that of the training set. Note that our models do not rely on reinforcement learning methods and utilize neither the information of QED nor valence rule; they learned only through unsupervised learning.

heading: A.7.4 ABLATION STUDY
text: To examine the effectiveness of the bias terms in the graph attention mechanism, we conducted an ablation study. Specifically, we evaluated two variants: GRAM without bias terms of graph attention in edge estimation, and GRAM without bias terms of graph attention in feature extraction.
The results are listed in Table 6. On all the synthetic graph datasets, removing bias terms in edge estimation degraded its performance. From this, we can see the importance of the bias terms in edge estimation for the better quality of generation. Also, removing bias terms in feature extraction degraded the performance on the B-A dataset. This is likely because its expressive power is limited.
On the other hand, the drop in the performance by removing bias terms in feature extraction is minor on the grid, lobster and community dataset. Considering the properties of these random graphs, this is likely because only local features were enough for these cases.
A.7.5 VISUALIZATION OF GENERATED GRAPHS
Visualizations of generated graphs on each dataset are shown in Figures 10, 11, 12, 13 and 14 (color is best). We used the same visualization method for all graphs. Different color corresponds to different node/edge labels on each dataset.
The graphs generated by GraphRNN are quite similar to those in the training set in terms of their topology. However, they completely failed to capture node/edge label patterns in most cases.
In contrast, the graphs generated by GRAM are similar to training samples in terms of both topology and node/edge label pattens.

heading: A.8 LIMITATIONS AND FUTURE WORK
text: While our models demonstrated superior performance on most of the datasets, they have some limitations. For example, on inference, one wrong prediction of node/edge label may collapse all the following generation processes, resulting in a bizarre graph generated. This is a deficit of its rich feature extraction process. A possible solution to this problem is, for example, to employ beam search. By applying beam search on inference, we can get rid of samples with a quite lower likelihood and avoid the above undesirable situations.
Additionally, although we reduced the computational complexity of the models by a significant amount, the feature extraction process still requires a large amount of computation. To this challenge, some methods proposed in the field of image processing and natural language processing would help to alleviate it.

Review summaries:
This paper presents new graph generative model (GRAM) which claims to tackle the scalability issue found is most of the published models. The propose architecture can scale on graphs from three perspective - number of graphs, number of nodes/edges and number of node/edge labels. This is achieved by sequentially generating the subgraph using graph attention and graph convolutional layers. While training, each of these subgraph can be trained in parallel. Further, paper applies couple of heuristics to reduce computational time and introduces a new non-domain specific evaluation metric for the generation of node/edge labeled graphs.