Deep Graph Translation

1 INTRODUCTION . In recent years , deep learning on graphs has seen a surge of interests , especially for graph representation and recognition tasks such as node-level classification ( Li et al. , 2016 ; Kipf & Welling , 2017 ; Veličković et al. , 2017 ; Gilmer et al. , 2017 ; Hamilton et al. , 2017 ) and graph-level classification ( Niepert et al. , 2016 ; Atwood et al. , 2016 ; Wu et al. , 2017 ) . Because of the successes in graph neural networks , researchers have recently started to explore the use of deep generative models for graph synthesis on practical applications such as designing new chemical molecular structures ( Simonovsky & Komodakis , 2018 ; You et al. , 2018 ) . This has led to many of the recent advances in deep graph generative models where some of these approaches are domain dependent models ( Kusner et al. , 2017 ; Dai et al. , 2018 ) for generating graphs with physical constrains , while some others consider the generation of generic graphs ( Li et al. , 2018 ; Samanta et al. , 2018 ; Jin et al. , 2018a ) . However , there are two main drawbacks of existing deep graph generative models . First , one significant limitation of the previous approaches is that most of these models are only suitable for small graphs with 40 or fewer nodes , which is mainly due to their one-node-per-step generation manner . More importantly , most of the existing graph generation models are unconditioned and thus ignore rich input graph information for generating a new graph . In many applications , it is crucial to guide the graph generation process by conditioning on an input graph , which can be cast as a graph translation learning problem – translating the input graph to the output graph . One straightforward way is to build a translation system by using a graph encoder-decoder architecture . However , there are several challenges for this type of approaches : 1 ) how to learn one-to-more mapping between the input graph and the target graphs . Different from the plain graph generation problem , a conditional graph synthesis task is to learn a distribution of target graphs conditioning on the input graph , which aims to capture the underlying implicit properties of the graphs , such as their scale-free characteristic . 2 ) how to jointly learn both local and global information for translation . One needs to not only learn the translation mapping in the local information ( i.e . neighborhood pattern of each node ) , but also in the global property of the whole graph ( e.g. , node degree distribution or graph density ) . To address the aforementioned challenges , we present a novel neural network architecture – GraphTranslation-Generative-Adversarial-Nets ( GT-GAN ) . We first propose a conditional graph GAN architecture that consists of an encoder-decoder translator and a conditional graph discriminator to learn the one-to-more mapping ( a conditional distribution ) for graph translation . To jointly embed the local and global information , we present a novel graph encoder including both the edge and the node convolution layers . In addition , we further propose a novel graph U-net with graph skips and dedicated graph deconvolution layers including both the edge and the node deconvolution layers . Finally , GT-GAN is scalable with at most quadratic computation and memory consumption in terms of the number of nodes in a graph , making it suitable for at least modest-scale graphs ( with hundreds of nodes , compared to the tens of nodes in most of existing graph generative models ) . We highlight our main contributions as follows : • We develop a generic framework GT-GAN consisting of a novel graph translator and conditional graph discriminator for learning a conditional distribution of target graphs given the input graphs . • We propose a novel graph encoder consisting of “ edge convolution ” layers that extract various relations among nodes containing both local and global information , and “ node convolution ” layers that embed the node representations based on the extracted relations . • We propose a novel graph decoder consisting of the “ edge deconvolution ” and “ node deconvolution ” layers , which can decode the node representations first into the latent relations of the target graph and then generate the final target graph . The graph skip-connection is also utilized to map the learned latent relations between the input and target graphs . • Extensive experiments have been conducted on both synthetic and real-world datasets on eight performance metrics to demonstrate the effectiveness and efficiency of the proposed model . 2 RELATED WORKS . Graph Neural Networks . The recent surge of research into GNN ( Graph Neural Networks ) can be generally divided into two categories : Graph Recurrent Networks and Graph Convolutional Networks . Graph Recurrent Networks originate from early work by Gori et al . ( 2005 ) ; Scarselli et al . ( 2009 ) and are based on recursive neural networks that have been extended by modern deep learning techniques such as gated recurrent units ( Li et al. , 2016 ) . The other category , Graph Convolutional Networks , originate from spectral graph convolutional neural networks ( Bruna et al. , 2014 ) , which were then extended by Defferrard et al . ( 2016 ) using fast localized convolutions , and further approximated by an efficient architecture for a semi-supervised setting proposed by Kipf & Welling ( 2017 ) . Selfattention mechanism and subgraph-level information are also explored later to further improve the representation power of learned node embeddings ( Veličković et al. , 2017 ; 2018 ; Bai et al. , 2019 ) . Graph generation . Most of the existing GNN based graph generation for general graphs have been proposed in the last two years and are based on VAE ( Simonovsky & Komodakis , 2018 ; Samanta et al. , 2018 ) and generative adversarial nets ( GANs ) ( Bojchevski et al. , 2018 ) , among others ( Li et al. , 2018 ; You et al. , 2018 ) . Most of these approaches generate nodes and edges sequentially to form a whole graph , leading to the issues of being sensitive to the generation order and very time-consuming for large graphs . Differently , GraphRNN ( You et al. , 2018 ) builds an autoregressive generative model on these sequences with LSTM model and has demonstrated its good scalability . Data Translation involved Graphs . A variety of graph-to-sequence models have been proposed to cope with different tasks including machine translation ( Beck et al. , 2018 ; Bastings et al. , 2017 ) , semantic parsing ( Xu et al. , 2018a ; b ; Song et al. , 2018 ) , and question generation ( Chen et al. , 2019 ) , and health status prediction ( Gao et al. , 2019 ) . The sequence-to-graph algorithms are generally popular with those working on NLP methods , including generating dependency graphs ( Gildea et al. , 2018 ; Wang et al. , 2018 ) and AMR structures ( Peng et al. , 2018 ) . A few of very recent attempts have also been made to develop graph-to-graph translation models . Jin et al . ( 2018b ) proposed a domain-specific graph translation model to deal with molecular optimization task by utilizing the domain knowledge - junction tree and molecule graph . Do et al . ( 2019 ) dealt with the chemical reaction product prediction problem by predicting the reaction sequences based on the input graph of molecules . Sun & Li ( 2019 ) proposed a RNN based model for encoding and decoding the directed acyclic graph ( converted from regular graphs ) , which can be viewed as a contemporary work to our work . However , this method is trained following the encoder-decoder architecture but in a supervised setting instead of learning a distribution of graphs . More importantly , it is difficult to scale to even modest-scale graph due to its one-node-per-step generation manner . 3 THE OVERALL ARCHITECTURE OF GT-GAN . In this section , we first present our problem formulation of graph translation problem . We then propose our new GT-GAN model for graph translation and discuss each component in detail in the subsequent sections . 3.1 PROBLEM FORMULATION FOR DEEP GRAPH TRANSLATION . Our goal is to learn an end-to-end translation mapping from an input graph to a target graph . Let an input graph GX = ( V , E , A , S ) such that V is the set of N nodes , E ⊆ V × V is the set of edges , and A ∈ RN×N is an adjacency matrix ( binary or weighted ) , where GX can be weighted or unweighted , directed or undirected . Let S ∈ RN×F be a node feature matrix with each row representing a node feature vector Si . Denote ei , j ∈ E as an edge from the node vi ∈ V to vj ∈ V ; Ai , j ∈ A therefore denotes the corresponding weight of the edge ei , j . Similarly , we define a target graph GY = ( V ′ , E ′ , A′ , S′ ) that shares the same node sets and node features with GX but with different topology and connection weights . Formally , graph translation is to learn a translator from an input graph GX ∈ GX with a random noise U to generate a target graph GY ∈ GY , where GX and GY denote the domains of the input and target graphs , respectively . The translation mapping is denoted as T : U , GX → GY . Note that since our aim is to learn a conditional distribution of the target graphs given an input graph , we can cast the graph translation as a conditional graph generation problem , where an input graph can be mapped into any target graph that may have different topologies yet follow the same distribution . In contrast , the graph generation , that are designed to learn a distribution of graphs and generate a new graph sample based on this distribution , typically uses variational autoencoder framework for graph generation . Therefore , the previous graph generation frameworks such as graphVAE ( Simonovsky & Komodakis , 2018 ) and GraphRNN ( You et al. , 2018 ) do not directly fit into `` translation '' setting . The Proposed GT-GAN Framework . Fig.1 shows our proposed generic GAN framework for graph translation that consists of a graph translator T and a conditional graph discriminator D. In this figure we assume the node feature has only one dimension for simplicity . Since our task is to train a conditional generator with “ one-to-many mapping '' instead of a deterministic one , the noise U is introduced by the dropout function ( Seltzer et al. , 2013 ) in each convolution and deconvolution layer , as shown ( in green lines ) in Fig.1 . Our graph translator T is trained to produce target graphs that can not be distinguished from “ real ” ones by our conditional graph discriminator D. Specifically , the generated target graph GY ′ = T ( GX , U ) can not be distinguished from the real one , GY , based on the current input graph GX . T and D undergo an adversarial training process based on input and target graphs by solving the following the loss function : L ( T , D ) = EGX , GY [ logD ( GY |GX ) ] + EGX , U [ log ( 1−D ( T ( GX , U ) |GX ) ) ] , ( 1 ) where T tries to minimize this objective while an adversarial D tries to maximize it , i.e . T ∗ = arg minT maxD L ( T , D ) . We also mix the GAN loss with the L1 loss to enforce sparsity similarity , which is also found useful in image translation problem ( Isola et al. , 2017 ) , Ll1 ( T ) = EA , A′ , U [ ‖A′ − T ( GX , U ) ‖1 ] , ( 2 ) where T ( GX , U ) refers to the adjacent matrix of generated graph . The training process is a trade-off between Ll1 and L ( T , D ) , which jointly enforces T ( GX , U ) and GY to follow a similar , but not necessarily identical topological pattern . Specifically , Ll1 makes T ( GX , U ) share the same rough outline of sparsity pattern as GY , while L ( T , D ) allows T ( GX , U ) to vary to some degree . Thus , the optimal objective T ∗ of the translator , which generates graphs that are as “ real ” as possible , is defined as : T ∗ = arg min T max D L ( T , D ) + Ll1 ( D ) , ( 3 ) The graph translator T is an encoder-decoder architecture , where we propose a new graph encoder to obtain the node representations of the input graph and propose the graph deconvolution with skips to generate the target graph , as shown in Fig.1 , which we elaborated in the followings sections . 3.2 GRAPH ENCODER The graph encoder aims to learn the representations of nodes based on the node features and graph topology of the input graph . One of crucial challenges is to learn both local and global information in the graph embedding . For instance , when learning translation between two scale-free graphs , one needs to translate both the local information ( i.e . n-hop neighborhood of each node ) and the scale-free property ( i.e . node degree distributions of whole graph ) from an input graph to a target graph . The Proposed Graph Convolution . To learn the local information , the proposed encoder learns each node representation based on its n-hop neighbors . To learn the global information , it learns each node representation by looking for more “ virtual neighbors ” regarding the latent relations from the aspect of the whole graph . As shown in Fig 2 , though Node 1 and 2 are separated far away in the original network , they have the similarities in some properties , such as neighborhood structure and node degree . These nodes are treated as virtually connected ( `` virtual neighbors '' ) . Thus , we first propose the “ edge convolution ” layers to learn a group of multimode relations from the topology of the input graph , which can include both the n-hop connections and the latent relations that are derived from their adjacent edges/relations . And then the “ node convolution ” layer is used to embed each node representations by aggregating its “ virtual neighbors ” that related to each latent relations . Fig.3 illustrates the details of these matrix operations involving graph convolution . In each “ edge convolution ” layer , each node pair ’ s latent relation is computed by its adjacent edges or the extracted adjacent relations from the last layer . In the directed graph , each node has incoming edge ( s ) and out-going edge ( s ) . Thus , there are two learnable parametric vectors φ and ψ as convolution filters for two directions to convolute the adjacent edges/relations for each node pairs . The relation El , mi , j in the mth relation mode of the lth layer is learned by the out-going edges/relations of node vi and the in-coming edges/relations of node vj , El , mi , j = ∑Rl−1 n=1 ( σ ( ∑N k1=1 El−1 , ni , k1 φ l , m k1 ) + σ ( ∑N k2=1 El−1 , nk2 , j ψ l , m k2 ) ) ( 4 ) where E1,1i , j ≡ Ai , j and φl , m ∈ RN×1 refers to the filter vector to be learned and φ l , m k1 refers to the element of φl , m that is related to node vk1 . Rl−1 refers to the number of relation modes extracted for the ( l − 1 ) th layer of the graph encoder . After learning the various modes of relations , the “ node convolution “ layer learns each node ’ s representations by aggregating its “ virtual neighbors ” in terms of each mode of relation . The mth feature vector of node representation tensor H̄mi ∈ R1×F for node vi is computed as : H̄mi = ∑Rl−1 n=1 ( σ ( ∑N k1=1 El−1 , ni , k1 µ m k1Sk1 ) + σ ( ∑N k2=1 El−1 , nk2 , i ν m k2Sk2 ) ) , ( 5 ) where H̄i ∈ RRl×F and Rl refers to the number of feature vectors in the “ node convolution ” layer . Here µm , νm ∈ RN×1 refer to the filter vectors for the two directions to be learned and µmk1 refers to the element of µ m that is related to node vk1 . H̄i is then flattened and transformed into a node representation vector Hi ∈ R1×C by a fully connected layer . C is the length of the node representation . Note that our graph encoder is designed for a directed graph , and it is easily generalized to an undirected graph , where the weight vector is shared by both directions .

Summary: In this work the authors tackle the problem of generating a given graph to a target output graph.  To achieve this they develop a novel deep graph generative model. The authors place a lot of emphasis on scalability. This is indeed a major computational bottleneck in prior work, allowing the deep generative models to generate graphs with few tenths of nodes.   The authors propose an architecture that consists of a graph translator, and a conditional graph discriminator. The GAN approach is able to give significant insights into the conditional distribution p(G|H) where H is the input graph. For the graph translator, the authors design novel graph encoders and decoders. The proposed encoder-decoder achieve the best possible results, compared to using established encoder/decoders as shown in ablation study.  The authors analyze the computational complexity of their work, and while they do not discuss the computational complexities of the other methods, it is clear from the experiments that their method scales better (e.g., Figure 4). To evaluate the output of the architecture, they use a variety of different graph characteristics. The proposed method outperforms the state-of-the-art. Furthermore, the proposed method is able to detect interesting anomalies as illustrated in the appendix  (hacker detection).