Original: D EEP G RAPH T RANSLATION
Revised: D EEP G RAPH T RANSLATION

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Deep graph generation models have achieved great successes recently, among which however, are typically unconditioned generative models that have no control over the target graphs given an input graph.
Revised: Deep graph generation models have achieved great successes recently, among which however, are typically unconditioned generative models that have no control over the target graphs given an input graph.

Original: In this paper, we propose a novel GraphTranslation-Generative-Adversarial-Networks (GT-GAN) that transforms the input graphs into their target output graphs.
Revised: In this paper, we propose a novel GraphTranslation-Generative-Adversarial-Networks (GT-GAN) that transforms the input graphs into their target output graphs.

Original: GT-GAN consists of a graph translator equipped with innovative graph convolution and deconvolution layers to learn the translation mapping considering both global and local features.
Revised: GT-GAN consists of a graph translator equipped with innovative graph convolution and deconvolution layers to learn the translation mapping considering both global and local features.

Original: A new conditional graph discriminator is proposed to classify the target graphs by conditioning on input graphs while training.
Revised: A new conditional graph discriminator is proposed to classify the target graphs by conditioning on input graphs while training.

Original: Extensive experiments on multiple synthetic and realworld datasets demonstrate that our proposed GT-GAN signiﬁcantly outperforms other baseline methods in terms of both effectiveness and scalability.
Revised: Extensive experiments on multiple synthetic and realworld datasets demonstrate that our proposed GT-GAN signiﬁcantly outperforms other baseline methods in terms of both effectiveness and scalability.

Original: For instance,
Revised: For instance,

Original: GT-GAN achieves at least 10X and 15X fasterruntimes than GraphRNN and RandomVAE, respectively, when the size of the graph is around 50.
Revised: GT-GAN performs at least 10 and 15 time faster than GraphRNN and RandomVAE, respectively, when the size of the graph is around 50.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: In recent years, deep learning on graphs has seen a surge of interests, especially for graph representation and recognition tasks such as node-level classiﬁcation (Li et al., 2016; Kipf & Welling, 2017;
Revised: In recent years, deep learning on graphs has seen a surge of interests, especially for graph representation and recognition tasks such as node-level classiﬁcation (Li et al., 2016; Kipf & Welling, 2017;

Original: Veli ˇ ckovi ´ c et al., 2017; Gilmer et al., 2017; Hamilton et al., 2017) and graph-level classiﬁcation (Niepert et al., 2016; Atwood et al., 2016; Wu et al., 2017).
Revised: Veli ˇ ckovi ´ c et al., 2017; Gilmer et al., 2017; Hamilton et al., 2017) and graph-level classiﬁcation (Niepert et al., 2016; Atwood et al., 2016; Wu et al., 2017).

Original: 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;
Revised: 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;

Original: You et al., 2018).
Revised: You et al., 2018).

Original: 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).
Revised: 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).

Original: However, there are two main drawbacks of existing deep graph generative models.
Revised: However, there are two main drawbacks of existing deep graph generative models.

Original: First, one signiﬁcant 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.
Revised: First, one signiﬁcant 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.

Original: More importantly, most of the existing graph generation models are unconditioned and thus ignore rich input graph information for generating a new graph.
Revised: More importantly, most of the existing graph generation models are unconditioned and thus ignore rich input graph information for generating a new graph.

Original: 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.
Revised: 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.

Original: One straightforward way is to build a translation system by using a graph encoder-decoder architecture.
Revised: One straightforward way is to build a translation system by using a graph encoder-decoder architecture.

Original: 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 .
Revised: 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 .

Original: 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.
Revised: 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.

Original: 2) how to jointly learn both local and global information for translation .
Revised: 2) how to jointly learn both local and global information for translation .

Original: 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).
Revised: 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).

Original: To address the aforementioned challenges, we present a novel neural network architecture – GraphTranslation-Generative-Adversarial-Nets (GT-GAN).
Revised: To address the aforementioned challenges, we present a novel neural network architecture – GraphTranslation-Generative-Adversarial-Nets (GT-GAN).

Original: We ﬁrst 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.
Revised: We ﬁrst 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.

Original: To jointly embed the local and global information, we present a novel graph encoder including both the edge and the node convolution layers.
Revised: To jointly embed the local and global information, we present a novel graph encoder including both the edge and the node convolution layers.

Original: 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.
Revised: 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.

Original: 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).
Revised: 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).

Original: We highlight our main contributions as follows:
Revised: We highlight our main contributions as follows:

Original: • 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.
Revised: • 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.

Original: • 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.
Revised: • 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.

Original: • We propose a novel graph decoder consisting of the “edge deconvolution” and “node deconvolution” layers, which can decode the node representations ﬁrst into the latent relations of the target graph and then generate the ﬁnal target graph.
Revised: • We propose a novel graph decoder consisting of the “edge deconvolution” and “node deconvolution” layers, which can decode the node representations ﬁrst into the latent relations of the target graph and then generate the ﬁnal target graph.

Original: The graph skip-connection is also utilized to map the learned latent relations between the input and target graphs.
Revised: The graph skip-connection is also utilized to map the learned latent relations between the input and target graphs.

Original: • Extensive experiments have been conducted on both synthetic and real-world datasets on eight performance metrics to demonstrate the effectiveness and efﬁciency of the proposed model.
Revised: • Extensive experiments have been conducted on both synthetic and real-world datasets on eight performance metrics to demonstrate the effectiveness and efﬁciency of the proposed model.

Original:  R ELATED W ORKS
Revised:  R ELATED W ORKS

Original: Graph Neural Networks .
Revised: Graph Neural Networks .

Original: The recent surge of research into GNN (Graph Neural Networks) can be generally divided into two categories: Graph Recurrent Networks and Graph Convolutional Networks.
Revised: The recent surge of research into GNN (Graph Neural Networks) can be generally divided into two categories: Graph Recurrent Networks and Graph Convolutional Networks.

Original: Graph Recurrent Networks originate from early work by Gori et al.
Revised: Graph Recurrent Networks originate from early work by Gori et al.

Original: ; Scarselli et al.
Revised: ; Scarselli et al.

Original: 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).
Revised: 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).

Original: 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.
Revised: 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.

Original: (2016) using fast localized convolutions, and further approximated by an efﬁcient architecture for a semi-supervised setting proposed by Kipf & Welling (2017).
Revised: (2016) using fast localized convolutions, and further approximated by an efﬁcient architecture for a semi-supervised setting proposed by Kipf & Welling (2017).

Original: Selfattention mechanism and subgraph-level information are also explored later to further improve the representation power of learned node embeddings (Veliˇckovi´c et al., 2017; 2018; Bai et al., 2019).
Revised: Selfattention mechanism and subgraph-level information are also explored later to further improve the representation power of learned node embeddings (Veliˇckovi´c et al., 2017; 2018; Bai et al., 2019).

Original: Graph generation .
Revised: Graph generation .

Original: 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;
Revised: 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;

Original: You et al., 2018).
Revised: You et al., 2018).

Original: 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.
Revised: 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.

Original: Differently, GraphRNN
Revised: Differently, GraphRNN

Original: (You et al., 2018) builds an autoregressive generative model on these sequences with LSTM model and has demonstrated its good scalability.
Revised: (You et al., 2018) builds an autoregressive generative model on these sequences with LSTM model and has demonstrated its good scalability.

Original: Data Translation involved Graphs .
Revised: Data Translation involved Graphs .

Original: 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).
Revised: 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).

Original: The sequence-to-graph algorithms are generally popular with those working on NLP methods, including generating dependency graphs (Gildea et al., 2018;
Revised: The sequence-to-graph algorithms are generally popular with those working on NLP methods, including generating dependency graphs (Gildea et al., 2018;

Original: Wang et al., 2018) and AMR structures (Peng et al., 2018).
Revised: Wang et al., 2018) and AMR structures (Peng et al., 2018).

Original: A few of very recent attempts have also been made to develop graph-to-graph translation models.
Revised: A few of very recent attempts have also been made to develop graph-to-graph translation models.

Original: Jin et al.
Revised: Jin et al.

Original: (2018b) proposed a domain-speciﬁc graph translation model to deal with molecular optimization task by utilizing the domain knowledge - junction tree and molecule graph.
Revised: (2018b) proposed a domain-speciﬁc graph translation model to deal with molecular optimization task by utilizing the domain knowledge - junction tree and molecule graph.

Original: Do et al.
Revised: Do et al.

Original: (2019) dealt with the chemical reaction product prediction problem by predicting the reaction sequences based on the input graph of molecules.
Revised: (2019) dealt with the chemical reaction product prediction problem by predicting the reaction sequences based on the input graph of molecules.

Original: 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.
Revised: 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.

Original: However, this method is trained following the encoder-decoder architecture but in a supervised setting instead of learning a distribution of graphs.
Revised: However, this method is trained following the encoder-decoder architecture but in a supervised setting instead of learning a distribution of graphs.

Original: More importantly, it is difﬁcult to scale to even modest-scale graph due to its one-node-per-step generation manner.
Revised: More importantly, it is difﬁcult to scale to even modest-scale graph due to its one-node-per-step generation manner.

Original:  T HE O VERALL A RCHITECTURE OF GT-GAN
Revised:  T HE O VERALL A RCHITECTURE OF GT-GAN

Original: In this section, we ﬁrst present our problem formulation of graph translation problem.
Revised: In this section, we ﬁrst present our problem formulation of graph translation problem.

Original: We then propose our new GT-GAN model for graph translation and discuss each component in detail in the subsequent sections.
Revised: We then propose our new GT-GAN model for graph translation and discuss each component in detail in the subsequent sections.

Original: 3. P ROBLEM F ORMULATION FOR D EEP G RAPH T RANSLATION
Revised: 3. P ROBLEM F ORMULATION FOR D EEP G RAPH T RANSLATION

Original: Our goal is to learn an end-to-end translation mapping from an input graph to a target graph .
Revised: Our goal is to learn an end-to-end translation mapping from an input graph to a target graph .

Original: Let an input graph G X
Revised: Let an input graph G X

Original: =
Revised: =

Original: ( V , E , A, S ) such that V is the set of N nodes,
Revised: ( V , E , A, S ) such that V is the set of N nodes,

Original: E ⊆
Revised: E ⊆

Original: V × V is the set of edges, and
Revised: V × V is the set of edges, and

Original: A ∈ R N × N is an adjacency matrix (binary or weighted), where G X can be weighted or unweighted, directed or undirected.
Revised: A ∈ R N × N is an adjacency matrix (binary or weighted), where G X can be weighted or unweighted, directed or undirected.

Original: Let S ∈ R N × F be a node feature matrix with each row representing a node feature vector S i .
Revised: Let S ∈ R N × F be a node feature matrix with each row representing a node feature vector S i .

Original: Denote e i,j ∈ E as an edge from the node v i ∈ V to v j ∈ V ; A i,
Revised: Denote e i,j ∈ E as an edge from the node v i ∈ V to v j ∈ V ; A i,

Original: j ∈
Revised: j ∈

Original: A therefore denotes the corresponding weight of the edge e i,j .
Revised: A therefore denotes the corresponding weight of the edge e i,j .

Original: Similarly, we deﬁne a target graph
Revised: Similarly, we deﬁne a target graph

Original: G Y =
Revised: G Y =

Original: ( V (cid:48) , E (cid:48) , A (cid:48) , S (cid:48) ) that shares the same node sets and node features with G X but with different topology and connection weights.
Revised: ( V (cid:48) , E (cid:48) , A (cid:48) , S (cid:48) ) that shares the same node sets and node features with G X but with different topology and connection weights.

Original: Formally, graph translation is to learn a translator from an input graph G X ∈ G X with a random noise U to generate a target graph G Y ∈ G Y , where G X and G Y denote the domains of the input and target graphs, respectively.
Revised: Formally, graph translation is to learn a translator from an input graph G X ∈ G X with a random noise U to generate a target graph G Y ∈ G Y , where G X and G Y denote the domains of the input and target graphs, respectively.

Original: The translation mapping is denoted as T : U, G X → G Y .
Revised: The translation mapping is denoted as T : U, G X → G Y .

Original: 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.
Revised: 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.

Original: 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.
Revised: 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.

Original: Therefore, the previous graph generation frameworks such as graphVAE (Simonovsky &
Revised: Therefore, the previous graph generation frameworks such as graphVAE (Simonovsky &

Original: Komodakis, 2018) and GraphRNN (You et al., 2018) do not directly ﬁt into "translation" setting.
Revised: Komodakis, 2018) and GraphRNN (You et al., 2018) do not directly ﬁt into "translation" setting.

Original: The Proposed GT-GAN Framework .
Revised: The Proposed GT-GAN Framework .

Original: Fig.1 shows our proposed generic GAN framework for graph translation that consists of a graph translator T and a conditional graph discriminator D .
Revised: Fig.1 shows our proposed generic GAN framework for graph translation that consists of a graph translator T and a conditional graph discriminator D .

Original: In this ﬁgure we assume the node feature has only one dimension for simplicity.
Revised: In this ﬁgure we assume the node feature has only one dimension for simplicity.

Original: Since our task is to train a conditional generater 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.
Revised: 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.

Original: Our graph translator T is trained to produce target graphs that cannot be distinguished from “real” ones by our conditional graph discriminator D .
Revised: Our graph translator T is trained to produce target graphs that cannot be distinguished from “real” ones by our conditional graph discriminator D .

Original: Speciﬁcally, the generated target graph G Y (cid:48) =
Revised: Speciﬁcally, the generated target graph G Y (cid:48) =

Original: T ( G X , U ) cannot be distinguished from the real one, G Y , based on the current input graph G X .
Revised: T ( G X , U ) cannot be distinguished from the real one, G Y , based on the current input graph G X .

Original: T and D undergo an adversarial training process based on input and target graphs by solving the following the loss function:
Revised: T and D undergo an adversarial training process based on input and target graphs by solving the following the loss function:

Original: [Equation]
Revised: [Equation]

Original: where T tries to minimize this objective while an adversarial D tries to maximize it, i.e. T ∗ =
Revised: where T tries to minimize this objective while an adversarial D tries to maximize it, i.e. T ∗ =

Original: arg min T max D L ( T , D ) .
Revised: arg min T max D L ( T , D ) .

Original: 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),
Revised: 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),

Original: [Equation]
Revised: [Equation]

Original: where T ( G X , U ) refers to the adjacent matrix of generated graph.
Revised: where T ( G X , U ) refers to the adjacent matrix of generated graph.

Original: The training process is a trade-off between L l 1 and L ( T , D ) , which jointly enforces T ( G X , U ) and G Y to follow a similar, but not necessarily identical topological pattern.
Revised: The training process is a trade-off between L l 1 and L ( T , D ) , which jointly enforces T ( G X , U ) and G Y to follow a similar, but not necessarily identical topological pattern.

Original: Speciﬁcally, L l 1 makes T ( G X , U ) share the same rough outline of sparsity pattern as G Y , while L ( T , D ) allows T ( G X , U ) to vary to some degree.
Revised: Speciﬁcally, L l 1 makes T ( G X , U ) share the same rough outline of sparsity pattern as G Y , while L ( T , D ) allows T ( G X , U ) to vary to some degree.

Original: Thus, the optimal objective T ∗ of the translator, which generates graphs that are as “real” as possible, is deﬁned as:
Revised: Thus, the optimal objective T ∗ of the translator, which generates graphs that are as “real” as possible, is deﬁned as:

Original: [Equation]
Revised: [Equation]

Original: 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. G
Revised: 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.

Original: [Figure]
Revised: [Figure]

Original: The graph encoder aims to learn the representations of nodes based on the node features and graph topology of the input graph.
Revised: The graph encoder aims to learn the representations of nodes based on the node features and graph topology of the input graph.

Original: One of crucial challenges is to learn both local and global information in the graph embedding.
Revised: One of crucial challenges is to learn both local and global information in the graph embedding.

Original: 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.
Revised: 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.

Original: The Proposed Graph Convolution .
Revised: The Proposed Graph Convolution .

Original: To learn the local information, the proposed encoder learns each node representation based on its n-hop neighbors.
Revised: To learn the local information, the proposed encoder learns each node representation based on its n-hop neighbors.

Original: 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.
Revised: 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.

Revised: As shown in Fig 2, though Nodeand 2 are separated far away in the original network, they have the similarities in some properties, such as neighborhood structure and node degree.

Revised: These nodes are treated as virtually connected ("virtual neighbors").

Original: Thus, we ﬁrst propose the “edge convolution” layers to learn a group of multi-mode 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 as shown in Fig.2(a).
Revised: Thus, we ﬁrst 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.

Original: And then the “node convolution” layer is used to embed each node representations by aggregating its “virtual neighbors” that related to each latent relations, as shown in Fig.2(b).
Revised: And then the “node convolution” layer is used to embed each node representations by aggregating its “virtual neighbors” that related to each latent relations.

Revised: Fig.3 illustrates the details of these matrix operations involving graph convolution.

Original: 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.
Revised: 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.

Original: In the directed graph, each node have incoming edge(s) and out-going edge(s).
Revised: In the directed graph, each node has incoming edge(s) and out-going edge(s).

Original: Thus, there are two learnable parametric vectors φ and ψ as convolution ﬁlters for two directions to convolute the adjacent edges/relations for each node pairs.
Revised: Thus, there are two learnable parametric vectors φ and ψ as convolution ﬁlters for two directions to convolute the adjacent edges/relations for each node pairs.

Original: The relation E l,mi,j in the m th relation mode of the l th layer is learned by the out-going edges/relations of node v i and the in-coming edges/relations of node v j ,
Revised: The relation E l,mi,j in the m th relation mode of the l th layer is learned by the out-going edges/relations of node v i and the in-coming edges/relations of node v j ,

Original: [Equation]
Revised: [Equation]

Original: (4) where E 1 , 1 i,j ≡ A  and φ l,m ∈ R N × 1 refers to the ﬁlter vector to be learned and φ l,mk 1 refers to the element of φ l,m that is related to node v k 1 .
Revised: (4) where E 1 , 1 i,j ≡ A i,j and φ l,m ∈ R N × 1 refers to the ﬁlter vector to be learned and φ l,mk 1 refers to the element of φ l,m that is related to node v k 1 .

Original: R l − 1 refers to the number of relation modes extracted for the ( l − 1) th layer of the graph encoder.
Revised: R l − 1 refers to the number of relation modes extracted for the ( l − 1) th layer of the graph encoder.

Original: 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.
Revised: 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.

Original: The m th feature vector of node representation tensor ¯ H mi ∈ R 1 × F for node v
Revised: The m th feature vector of node representation tensor ¯ H mi ∈ R 1 × F for node v

Original: i is computed as:
Revised: i is computed as:

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: where ¯ H i ∈ R R l × F and R l refers to the number of feature vectors in the “node comvolution” layer.
Revised: where ¯ H i ∈ R R l × F and R l refers to the number of feature vectors in the “node convolution” layer.

Original: Here µ m , ν m ∈ R N × 1 refer to the ﬁlter vectors for the two directions to be learned and µ mk 1 refers to the element of µ m that is related to node v k 1 .
Revised: Here µ m , ν m ∈ R N × 1 refer to the ﬁlter vectors for the two directions to be learned and µ mk 1 refers to the element of µ m that is related to node v k 1 .

Original: ¯ H i is then ﬂattened and transformed into a node representation vector H
Revised: ¯ H i is then ﬂattened and transformed into a node representation vector H

Original: i ∈ R 1 × C by a fully connected layer.
Revised: i ∈ R 1 × C by a fully connected layer.

Original: C is the length of the node representation.
Revised: C is the length of the node representation.

Original: 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.
Revised: 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.

Original: 3. G RAPH D ECODER
Revised: 3. G RAPH D ECODER

Original: The decoder aims to generate the edges of the target graph by taking the extracted latent information of the input graph.
Revised: The decoder aims to generate the edges of the target graph by taking the extracted latent information of the input graph.

Original: It is straightforward to directly use the embedded node representation of the last layer to generate the target graph.
Revised: It is straightforward to directly use the embedded node representation of the last layer to generate the target graph.

Original: However, the extracted information from each layer in the encoder could also be useful for generating the target graph.
Revised: However, the extracted information from each layer in the encoder could also be useful for generating the target graph.

Original: Thus, we consider all possible information learned in the encoder to be fed into a graph decoder.
Revised: Thus, we consider all possible information learned in the encoder to be fed into a graph decoder.

Original: Motivated by these observations, we propose a graph U-Net consisting of graph skips and dedicated graph deconvolution layers.
Revised: Motivated by these observations, we propose a graph U-Net consisting of graph skips and dedicated graph deconvolution layers.

Original: The graph deconvolution decodes the single node (or edge) information to yield its incoming and outgoing adjacent edges as a mirrored graph convolution process.
Revised: The graph deconvolution decodes the single node (or edge) information to yield its incoming and outgoing adjacent edges as a mirrored graph convolution process.

Original: In addition, several skips are implemented to map the learned information of each layer in the encoder to mirror the corresponding layers in the decoder.
Revised: In addition, several skips are implemented to map the learned information of each layer in the encoder to mirror the corresponding layers in the decoder.

Original: Similar Graph U-Net was proposed in (Gao & Ji, 2019).
Revised: Similar Graph U-Net was proposed in (Gao & Ji, 2019).

Original: The key difference is that their U-Net is barely a graph embedding method by using the old graph topology from pooling part to embed nodes during unpooling part.
Revised: The key difference is that their U-Net is barely a graph embedding method by using the old graph topology from pooling part to embed nodes during unpooling part.

Original: However, our Graph U-Net can not only do node embedding in graph encoder but also generate the new graph’s topology in the graph decoder, which is necessary for the graph translation problem.
Revised: However, our Graph U-Net can not only do node embedding in graph encoder but also generate the new graph’s topology in the graph decoder, which is necessary for the graph translation problem.

Original: The proposed Graph Deconvolution .
Revised: The proposed Graph Deconvolution .

Original: The proposed graph deconvolution technique incorporates both “node deconvolution” and “edge deconvolution” layers.
Revised: The proposed graph deconvolution technique incorporates both “node deconvolution” and “edge deconvolution” layers.

Original: First, the “node deconvolution” layer are used to generates the latent multi-mode relations of the target graph based on the learned latent node representations.
Revised: First, the “node deconvolution” layer are used to generate the latent multi-mode relations of the target graph based on the learned latent node representations.

Original: As shown in Fig. 2(c), “node deconvolution” is a reversed process of the “node” convolution.
Revised: As shown in Fig. 2(c), “node deconvolution” is a reversed process of the “node” convolution.

Original: Since each node has an inﬂuence to its relations connecting to other nodes.
Revised: Since each node has an inﬂuence to its relations connecting to other nodes.

Original: Then the relation E 1 ,m i,j between node v i and node v j in the m th relation mode of the l th “node” deconvolution layer in the decoder can be computed as follows:
Revised: Then the relation E 1 ,m i,j between node v i and node v j in the m th relation mode of the l th “node” deconvolution layer in the decoder can be computed as follows:

Original: [Equation]
Revised: [Equation]

Original: where σ ( H ni ¯ µ mj ) means the deconvolution contribution of node v i to its relation with node v j made by the n th element of its node representations, and ¯ µ mj represents the element of the deconvolution ﬁlter vector ¯ µ m ∈ R 1 × N that is related to node v j .
Revised: where σ ( H ni ¯ µ mj ) means the deconvolution contribution of node v i to its relation with node v j made by the n th element of its node representations, and ¯ µ mj represents the element of the deconvolution ﬁlter vector ¯ µ m ∈ R 1 × N that is related to node v j .

Original: We can now recursively apply our proposed “edge deconvolution“ layer to decode the latent relation between each pair of nodes from the upper layer to those of lower layer.
Revised: We can now recursively apply our proposed “edge deconvolution“ layer to decode the latent relation between each pair of nodes from the upper layer to those of lower layer.

Original: As a reversed way of “edge” convolution, the relation of each pair of nodes in the ( l − 1) th layer can make contribution to generating itself and its adjacent relations in the l th layer, as shown in Fig. 2(d).
Revised: As a reversed way of “edge” convolution, the relation of each pair of nodes in the ( l − 1) th layer can make contribution to generating itself and its adjacent relations in the l th layer, as shown in Fig. 2(d).

Original: Thus, the relation
Revised: Thus, the relation

Original: E l,mi,j between node v i and node v j in the l th layer is computed as follows:
Revised: E l,mi,j between node v i and node v j in the l th layer is computed as follows:

Original: [Equation]
Revised: [Equation]

Original: where ¯ φ l,m (cid:80) Nk 1 =1 E l − 1 ,n i,kis interpreted as the decoded contribution of node i to its relations with node v j , and ¯ φ l,m refers to the element of deconvolution ﬁlter vector that is related to node v
Revised: where ¯ φ l,m (cid:80) Nk 1 =1 E l − 1 ,n i,kis interpreted as the decoded contribution of node i to its relations with node v j , and ¯ φ l,m refers to the element of deconvolution ﬁlter vector that is related to node v

Original: j . R (cid:48)
Revised: j . R (cid:48)

Original: l −refers to the number of relation modes extracted by the ( l − 1) th layer in the graph decoder.
Revised: l −refers to the number of relation modes extracted by the ( l − 1) th layer in the graph decoder.

Original: The output of the last “edge” deconvolution layer denotes the edges of the target graph.
Revised: The output of the last “edge” deconvolution layer denotes the edges of the target graph.

Original: Skips for graph deconvolution .
Revised: Skips for graph deconvolution .

Original: Based on the graph deconvolution above, it is possible to utilize skips to link the extracted latent relation sets of each layers in the graph encoder with those in the graph decoder.
Revised: Based on the graph deconvolution above, it is possible to utilize skips to link the extracted latent relation sets of each layers in the graph encoder with those in the graph decoder.

Original: Speciﬁcally, the output of the l th “edge deconvolution” layer with R l channels in the decoder is concatenated with the output of the l th “edge convolution” layer with R (cid:48)
Revised: Speciﬁcally, the output of the l th “edge deconvolution” layer with R l channels in the decoder is concatenated with the output of the l th “edge convolution” layer with R (cid:48)

Original: l channels in encoder to form joint R l + R (cid:48)
Revised: l channels in encoder to form joint R l + R (cid:48)

Original: l channels, which are then input into the ( l + 1) th deconvolution layer.
Revised: l channels, which are then input into the ( l + 1) th deconvolution layer.

Original: 3. C ONDITIONAL G RAPH D ISCRIMINATOR
Revised: 3. C ONDITIONAL G RAPH D ISCRIMINATOR

Original: The graph discriminator must distinguish between the “translated” target graph and the “real” ones based on the input graphs, as this helps to train the generator in an adversarial way.
Revised: The graph discriminator must distinguish between the “translated” target graph and the “real” ones based on the input graphs, as this helps to train the generator in an adversarial way.

Original: Technically, this requires the discriminator to accept two graphs simultaneously as inputs (a target graph and an input graph or a generated graph and an input graph), and classify the two graphs as either related or not.
Revised: Technically, this requires the discriminator to accept two graphs simultaneously as inputs (a target graph and an input graph or a generated graph and an input graph), and classify the two graphs as either related or not.

Original: Thus, we propose a conditional graph discriminator (CGD) which leverages the same graph convolution layers in the translator for the graph classiﬁcation, as shown in Fig.1.
Revised: Thus, we propose a conditional graph discriminator (CGD) which leverages the same graph convolution layers in the translator for the graph classiﬁcation, as shown in Fig.1.

Original: Speciﬁcally, the input and target graphs are both ingested by CGD and stacked into a N × N × 2 tensor which can be considered a 2-channel input.
Revised: Speciﬁcally, the input and target graphs are both ingested by CGD and stacked into a N × N × 2 tensor which can be considered a 2-channel input.

Original: After obtaining the node representations, the graph-level embedding is computed by summing these node embeddings.
Revised: After obtaining the node representations, the graph-level embedding is computed by summing these node embeddings.

Original: Finally, a softmax layer is implemented to distinguish the input graph-pair from the real graph or generated graph.
Revised: Finally, a softmax layer is implemented to distinguish the input graph-pair from the real graph or generated graph.

Original: 3. C OMPUTATIONAL COMPLEXITY ANALYSIS
Revised: 3. C OMPUTATIONAL COMPLEXITY ANALYSIS

Original: The graph encoder and decoder shares the same time complexity.
Revised: The graph encoder and decoder shares the same time complexity.

Original: Without loss of generality, we assume all the hidden layers have the same number of feature maps as M .
Revised: Without loss of generality, we assume all the hidden layers have the same number of feature maps as M .

Original: P is the length of the fully connected layer in CGD.
Revised: P is the length of the fully connected layer in CGD.

Original: The worst-case total complexity of GT-GAN (i.e., the dense graph) is now O (9 N 2 M 

Revised: The worst-case total complexity of GT-GAN (i.e., the dense graph) is now O (9 N 2 M

Original: + 3 N 2 M 2 + N 2 MP ) , where the ﬁrst, second, and third terms represent “edge convolutions”, “node convolutions”, and fully connected layers in the graph discriminator, respectively.
Revised: + 3 N 2 M 2 + N 2 MP ) , where the ﬁrst, second, and third terms represent “edge convolutions”, “node convolutions”, and fully connected layers in the graph discriminator, respectively.

Original: Similarly, the total memory consumption for GT-GAN is O ((9 NM 2 + 9 N 2 M ) + (3 NM 2 + 3 NM )
Revised: Similarly, the total memory consumption for GT-GAN is O ((9 NM 2 + 9 N 2 M ) + (3 NM 2 + 3 NM )

Original: + ( N 2 MP + P )) .
Revised: + ( N 2 MP + P )) .

Original: In practice, many graphs are likely be sparse, thus it further reduces the computational and memory cost to O ( N ) by using sparse matrix-vector operations (You et al., 2018), which paves the way toward modest scale graphs with hundreds or thousands of nodes.
Revised: In practice, many graphs are likely be sparse, thus it further reduces the computational and memory cost to O ( N ) by using sparse matrix-vector operations (You et al., 2018), which paves the way toward modest scale graphs with hundreds or thousands of nodes, compared to most of existing graph generation methods, which often have O ( N 3 ) or even O ( N 4 ) .

Original:  E XPERIMENT
Revised:  E XPERIMENT

Original: This section reports the results of extensive experiments and ablation studies carried out to test the performance of GT-GAN on two synthetic and two real-world datasets.
Revised: This section reports the results of extensive experiments and ablation studies carried out to test the performance of GT-GAN on two synthetic and two real-world datasets.

Original: All experiments were conducted on a 64-bit machine with Nvidia GPU (GTX 1070,1683 MHz, 8 GB GDDR5).
Revised: All experiments were conducted on a 64-bit machine with Nvidia GPU (GTX 1070,1683 MHz, 8 GB GDDR5).

Original: The code and data utilized are available at https://github.com/anonymous1025/Deep-Graph-Translation- .
Revised: The code and data utilized are available at https://github.com/anonymous1025/Deep-Graph-Translation- .

Original: 4. D ATASETS
Revised: 4. D ATASETS

Original: The experimental settings for each dataset were as follows.
Revised: The experimental settings for each dataset were as follows.

Original: The rules for generating synthetic input-target graph pairs and the process of collecting the real-world graphs is provided in Appendix.
Revised: The rules for generating synthetic input-target graph pairs and the process of collecting the real-world graphs is provided in Appendix.

Original: Two synthetic datasets: Two groups of synthetic datasets were used to validate the performance of the proposed GT-GAN: a scale-free graph dataset and a Poisson-random graph dataset.
Revised: Two synthetic datasets: Two groups of synthetic datasets were used to validate the performance of the proposed GT-GAN: a scale-free graph dataset and a Poisson-random graph dataset.

Original: Each group has ﬁve subsets with different graph sizes (number of nodes): 10, 20, 50, 100 and 150.
Revised: Each group has ﬁve subsets with different graph sizes (number of nodes): 10, 20, 50, 100 and 150.

Original: Each subset consists of 5000 input-target graph pairs; 2500 pairs were used for training and the remainingfor testing.
Revised: Each subset consists of 5000 input-target graph pairs; 2500 pairs were used for training and the remainingfor testing.

Original: User authentication datasets .
Revised: User authentication datasets .

Original: The goal of this application was to forecast future potential malicious authentication graphs given the user’s normal authentication graph.
Revised: The goal of this application was to forecast future potential malicious authentication graphs given the user’s normal authentication graph.

Original: Each user authentication graph is a directed weighted graph, where nodes represent computers and the weights of the edges represent the authentication activities at certain frequencies.
Revised: Each user authentication graph is a directed weighted graph, where nodes represent computers and the weights of the edges represent the authentication activities at certain frequencies.

Original: There are 78 pairs of graphs (malicious and normal behavior) of graph size 50 and 315 pairs of graphs of graph size 300 from 97 users in two subsets.
Revised: There are 78 pairs of graphs (malicious and normal behavior) of graph size 50 and 315 pairs of graphs of graph size 300 from 97 users in two subsets.

Original: We performed a 2-fold cross-validations and 3-fold cross-validation, respectively, for the two subsets.
Revised: We performed a 2-fold cross-validations and 3-fold cross-validation, respectively, for the two subsets.

Revised: [Table]

Original: Internet of Things (IOT) datasets .
Revised: Internet of Things (IOT) datasets .

Original: This application focused IOT network malware conﬁnement prediction (predicting optimal network operation given a compromised one).
Revised: This application focused IOT network malware conﬁnement prediction (predicting optimal network operation given a compromised one).

Original: There are three subsets of graph pairs with different sizes (20, 40 and 60), where the nodes represent devices and the node attributes indicating the compromised status of the nodes.
Revised: There are three subsets of graph pairs with different sizes (20, 40 and 60), where the nodes represent devices and the node attributes indicating the compromised status of the nodes.

Original: The weights of the edges represent the distance between two devices.
Revised: The weights of the edges represent the distance between two devices.

Original: There are 334 pairs of input (compromised IOT) and target graphs (optimal IOT) in each subset and each is divided into two parts for the 2-fold cross-validation.
Revised: There are 334 pairs of input (compromised IOT) and target graphs (optimal IOT) in each subset and each is divided into two parts for the 2-fold cross-validation.

Original: 4. B ASELINE M ETHODS
Revised: 4. B ASELINE M ETHODS

Original: We compare our GT-GAN against ﬁve state-of-the-art graph generation methods: 1) GraphRNN
Revised: We compare our GT-GAN against ﬁve state-of-the-art graph generation methods: 1) GraphRNN

Original: (You et al., 2018) is a new graph generation method based on sequential generation with the LSTM model; 2) GraphVAE
Revised: (You et al., 2018) is a new graph generation method based on sequential generation with the LSTM model; 2) GraphVAE

Original: (Simonovsky & Komodakis, 2018) is a probability-based graph generation method for small graphs; 3)
Revised: (Simonovsky & Komodakis, 2018) is a probability-based graph generation method for small graphs; 3)

Original: GraphGMG (Li et al., 2018)is a framework based upon graph neural networks for small single graphs; 4) RandomVAE (Samanta et al., 2018) was described earlier; and 5) S-Generator is the part of our full model GT-GAN, which essentially is a graph translator with L loss but no discriminator.
Revised: GraphGMG (Li et al., 2018)is a framework based upon graph neural networks for small single graphs; 4) RandomVAE (Samanta et al., 2018) was described earlier; and 5) S-Generator is the part of our full model GT-GAN, which essentially is a graph translator with L loss but no discriminator.

Original: We propose this S-Generator model in order to evaluate the necessity of the proposed GT-GAN framework to learn the one-to-many mappings.
Revised: We propose this S-Generator model in order to evaluate the necessity of the proposed GT-GAN framework to learn the one-to-many mappings.

Original: All the comparison methods were trained on the malicious graphs without conditioning on the input graphs due to the models’ inherent capability limitations.
Revised: All the comparison methods were trained on the malicious graphs without conditioning on the input graphs due to the models’ inherent capability limitations.

Original: The datasets were assigned to each comparison model for the experiment based on their scalability  size.[Table]
Revised: The datasets were assigned to each comparison model for the experiment based on their scalability in terms of graph size.

Original: 4. E VALUATION R ESULTS ON S YNTHETIC D ATASETS
Revised: 4. E VALUATION R ESULTS ON S YNTHETIC D ATASETS

Original: Results for the synthetic datasets .
Revised: Results for the synthetic datasets .

Original: To evaluate the similarity between the generated and real target graphs for scale-free dataset, we selected eight performance metrics: 1) two metrics are distances between generated and real graph in terms of Eigenvector centrality (En-dist)
Revised: To evaluate the similarity between the generated and real target graphs for scale-free dataset, we selected eight performance metrics: 1) two metrics are distances between generated and real graph in terms of Eigenvector centrality (En-dist)

Original: (Bonacich, 1987) and Closeness centrality (C-dist) (Freeman, 1978), where the lower the distance, the better the performance; 2) two metrics are similarity score based on the graph kernels of Weisfeiler Lehman kernel(wl-sim)
Revised: (Bonacich, 1987) and Closeness centrality (C-dist) (Freeman, 1978), where the lower the distance, the better the performance; 2) two metrics are similarity score based on the graph kernels of Weisfeiler Lehman kernel(wl-sim)

Original: (Shervashidze et al., 2011) and Lovasz Theta Kernel(lt-sim) (Johansson & et al, 2014), where the higher the score, the better the performance; 3) four metrics are used to evaluate the the node degree distribution correlation between the generated and real target graphs by: Jensen-Shannon distances (JS), the Hellinger Distance (HD), the Bhattacharyya Distance (BD) and the Wasserstein
Revised: (Shervashidze et al., 2011) and Lovasz Theta Kernel(lt-sim) (Johansson & et al, 2014), where the higher the score, the better the performance; 3) four metrics are used to evaluate the the node degree distribution correlation between the generated and real target graphs by: Jensen-Shannon distances (JS), the Hellinger Distance (HD), the Bhattacharyya Distance (BD) and the Wasserstein

Original: Distances (WD), where the lower the score, the better the performance.
Revised: Distances (WD), where the lower the score, the better the performance.

Original: As shown in table 1, our GT-GAN consistently outperforms all other baselines by a large margin, especially when the graph size becomes large (i.e.having the superiority of 34.6% than other methods when size is 150).
Revised: As shown in table 1, our GT-GAN consistently outperforms all other baselines by a large margin, especially when the graph size becomes large (i.e.having the superiority of 34.6% than other methods when size is 150).

Original: The “Inf” entries represent distance over 1000.
Revised: The “Inf” entries represent distance over 1000.

Original: S-Generator is generally the second best methods in terms of these four evaluation metrics, highlighting the effectiveness of our proposed graph encoder and decoder.
Revised: S-Generator is generally the second best methods in terms of these four evaluation metrics, highlighting the effectiveness of our proposed graph encoder and decoder.

Original: To verify whether GT-GAN can indeed discover the underlying ground-truth translation rules between input-target pairs, we draw the node degree distribution curve for three pairs of generated and real target graphs by GT-GAN, as shown in Fig. 
Revised: To verify whether GT-GAN can indeed discover the underlying ground-truth translation rules between input-target pairs, we draw the node degree distribution curve for three pairs of generated and real target graphs by GT-GAN, as shown in Fig. 4.

Original: The curves of the generated graphs closely follow the power-law rule and become even closer to the real graphs as the graph size increases, which is consistent with the ﬁndings in Table 1.
Revised: The curves of the generated graphs closely follow the power-law rule and become even closer to the real graphs as the graph size increases, which is consistent with the ﬁndings in Table 1.

Original: This demonstrates that our GT-GAN model successfully learns the inherent properties of scale-free graphs during translation.
Revised: This demonstrates that our GT-GAN model successfully learns the inherent properties of scale-free graphs during translation.

Original: Similar observations for the evaluation metrics (e.g. average degree, repository and density) of the Poisson random datasets and remaining scale-free subsets can be found in Appendixes B and C.
Revised: Similar observations for the evaluation metrics (e.g. average degree, repository and density) of the Poisson random datasets and remaining scale-free subsets can be found in Appendixes B and C.

Original: 4. E VALUATION R ESULTS ON R EAL A PPLICATION D ATASETS

Original: Results for the user authentication datasets .
Revised: Results for the user authentication datasets .

Original: For the real world dataset, we design an indirect evaluation metric inspired from a real-world classiﬁcation problem: label imbalance issues.
Revised: For the real world dataset, we design an indirect evaluation metric inspired from a real-world classiﬁcation problem: label imbalance issues.

Original: For example, we may want to build a classiﬁer to determine whether an authentication graph of a user is malicious (positive) or normal (negative), but this user has few malicious records.
Revised: For example, we may want to build a classiﬁer to determine whether an authentication graph of a user is malicious (positive) or normal (negative), but this user has few malicious records.

Original: For this difﬁcult task, the graphs (i [Table] e., malicious graphs) generated by GT-GAN, which has been trained on other users’ records, can be utilized as positive samples to train the classiﬁer.
Revised: For this difﬁcult task, the graphs (i.e., malicious graphs) generated by GT-GAN, which has been trained on other users’ records, can be utilized as positive samples to train the classiﬁer.

Original: Speciﬁcally, when evaluating, the test set is further split evenly into two subsets.
Revised: Speciﬁcally, when evaluating, the test set is further split evenly into two subsets.

Original: The ﬁrst subset is used to train a graph classiﬁer, as proposed by Nikolentzos et al.
Revised: The ﬁrst subset is used to train a graph classiﬁer, as proposed by Nikolentzos et al.

Original: (2017), using only the normal graphs plus the generated malicious graphs.
Revised: (2017), using only the normal graphs plus the generated malicious graphs.

Original: The second subset, which contains both the normal and real malicious graphs can then be used to validate the trained classiﬁer.
Revised: The second subset, which contains both the normal and real malicious graphs can then be used to validate the trained classiﬁer.

Original: In addition, a “gold standard” classiﬁer trained on both normal and real malicious graphs acts as the “best-possible-performer” and is used to evaluate all the different generative models to judge how “real” the graphs they generate are.
Revised: In addition, a “gold standard” classiﬁer trained on both normal and real malicious graphs acts as the “best-possible-performer” and is used to evaluate all the different generative models to judge how “real” the graphs they generate are.

Original: We refer readers to the detailed evaluations in Appendix E
Revised: We refer readers to the detailed evaluations in Appendix E.

Original: [Table]
Revised: [Table]

Original:  [Table] 
Revised: [Figure] [Table] [Table] As shown in Table

Original: [Table]
Revised: [Table]

Original: As shown in Table 2, classiﬁers trained by the graphs generated by GT-GAN can classify normal and hacked behaviors effectively with AUC above 0.78, which is well above the 0.5 obtained using a random model.
Revised: classiﬁers trained by the graphs generated by GT-GAN can classify normal and hacked behaviors effectively with AUC above 0.78, which is well above the 0.5 obtained using a random model.

Original: GT-GAN signiﬁcantly outperforms other methods by around 25%, 16%, 24.5% and 22.1%, respectively, on the four metrics: precision (P), recall (R), AUC and F1-score for the trained classiﬁer.
Revised: GT-GAN signiﬁcantly outperforms other methods by around 25%, 16%, 24.5% and 22.1%, respectively, on the four metrics: precision (P), recall (R), AUC and F1-score for the trained classiﬁer.

Original: GT-GAN performs consistently better than other methods when the graph size rises from 50 to 300.
Revised: GT-GAN performs consistently better than other methods when the graph size rises from 50 to 300.

Original: In addition, GT-GAN clearly outperformed the S-Genertor in this evaluation setting.
Revised: In addition, GT-GAN clearly outperformed the S-Genertor in this evaluation setting.

Original: This conﬁrms that using a translator alone to learn a deterministic output given an input graph is not sufﬁcient to capture the generic distribution of the target graphs.
Revised: This conﬁrms that using a translator alone to learn a deterministic output given an input graph is not sufﬁcient to capture the generic distribution of the target graphs.

Original: In addition, the four direct evaluation mentioned above are also tested and the results can be found in Appendix C.
Revised: In addition, the four direct evaluation mentioned above are also tested and the results can be found in Appendix C.

Original: Results on IOT dataset .
Revised: Results on IOT dataset .

Original: Table 3 compared the performance of GT-GAN and other comparison methods for the IOT dataset by examining the edges of the generated and real target graphs for four metrics: MSE (mean squared error), R2 (coefﬁcient of determination score), Pearson Correlation (P) of adjacent matrix, and ACC (Accuray) for the correct existence of edges among all the pairs of nodes.
Revised: Table 3 compared the performance of GT-GAN and other comparison methods for the IOT dataset by examining the edges of the generated and real target graphs for four metrics: MSE (mean squared error), R2 (coefﬁcient of determination score), Pearson Correlation (P) of adjacent matrix, and ACC (Accuray) for the correct existence of edges among all the pairs of nodes.

Original: The results show that GT-GAN performed almost the best for all the three subsets.
Revised: The results show that GT-GAN performed almost the best for all the three subsets.

Original: GT-GAN got highest Pearson Correlation of around 0.8 for all three subsets compared to the other methods which had Pearson Correlations below 0.4.
Revised: GT-GAN got highest Pearson Correlation of around 0.8 for all three subsets compared to the other methods which had Pearson Correlations below 0.4.

Original: Due to the L1-loss required to maintain the topology pattern similarity, GT-GAN also outperformed the comparison methods with around 8% ,26% and 40% superiority in ACC for the three subsets, respectively, and had the smallest MSE, at just one tenth of those achieved by comparison methods.
Revised: Due to the L1-loss required to maintain the topology pattern similarity, GT-GAN also outperformed the comparison methods with around 8% ,26% and 40% superiority in ACC for the three subsets, respectively, and had the smallest MSE, at just one tenth of those achieved by comparison methods.

Original: 4. A BLATION S TUDY ON THE G RAPH E NCODERS AND D ECODER
Revised: 4. A BLATION S TUDY ON THE G RAPH E NCODERS AND D ECODER

Original:  To further validate the superiority of the proposed graph convolution and deconvolution layers, an ablation experiment was conducted by replacing the encoder and decoder with node embedding and decoder methods normaly used.
Revised: [Table] To further validate the superiority of the proposed graph convolution and deconvolution layers [Table] an ablation experiment was conducted by replacing the encoder and decoder with node embedding and decoder methods normaly used.

Original: The graph encoder was replaced by the GCN (Kipf & Welling, 2017),
Revised: The graph encoder was replaced by the GCN (Kipf & Welling, 2017),

Original: DCNN (Atwood & Towsley, 2016) and Graph U-NET (Gao & Ji, 2019), both of which consider edge and node features for graph embedding.
Revised: DCNN (Atwood & Towsley, 2016) and Graph U-NET (Gao & Ji, 2019) [Table] both of which consider edge and node features for graph embedding.

Original: The graph decoder was replaced by the decoder in
Revised: The graph decoder was replaced by the decoder in

Original: VGAE (Kipf & Welling, 2016).
Revised: VGAE (Kipf & Welling, 2016).

Original: There were thus three method combinations for comparison.
Revised: There were thus three method combinations for comparison.

Original: Table.
Revised: Table.

Original: 4 shows the results of the ablation study of the proposed encoder and decoder on part of the scale-free (Scale), user authentication (Auth) and IOT datasets.
Revised: 4 shows the results of the ablation study of the proposed encoder and decoder on part of the scale-free (Scale), user authentication (Auth) and IOT datasets.

Original: There are two major ﬁndings here.
Revised: There are two major ﬁndings here.

Original: First, the encoder of GT-GAN outperformed both the GCN- and DCNN- based encoders by a large margin on these datasets, especially for the real-world datasets, where the edges of the graphs can have a very complex meaning.
Revised: First, the encoder of GT-GAN outperformed both the GCN- and DCNN- based encoders by a large margin on these datasets, especially for the real-world datasets, where the edges of the graphs can have a very complex meaning.

Original: For example, on Auth-I, GT-GAN performed 43%, 50%, 31%, and 38% better on average, when compared with the GCN and DCNN encoders in terms of precision, recall, AUC and F1-scores, respectively.
Revised: For example, on Auth-I, GT-GAN performed 43%, 50%, 31%, and 38% better on average, when compared with the GCN and DCNN encoders in terms of precision, recall, AUC and F1-scores, respectively.

Original: Second, the proposed decoder in GT-GAN was deemed both effective and irreplaceable for graph generation.
Revised: Second, the proposed decoder in GT-GAN was deemed both effective and irreplaceable for graph generation.

Original: For example, on IOT-III, GT-GAN performed 6.97%,[Table] 45.00%, and 83.33% better than the decoder in VGAE in terms of ACC, P and R2, respectively, as well as a low MSE below 1000.
Revised: For example, on IOT-III, GT-GAN performed 6.97%, 45.00%, and 83.33% better than the decoder in VGAE in terms of ACC, P and R2, respectively, as well as a low MSE below 1000.

Original: 4. M ODEL S CALABILITY A NALYSIS
Revised: 4. M ODEL S CALABILITY A NALYSIS

Original: We compare the scalability of GT-GAN against three graph generation methods as shown in Fig.4.
Revised: We compare the scalability of GT-GAN against three graph generation methods as shown in Fig.5.

Original: Our GT-GAN model signiﬁcantly outperforms other state-of-the-art baselines in terms of both computational time and memory consumption.
Revised: Our GT-GAN model signiﬁcantly outperforms other state-of-the-art baselines in terms of both computational time and memory consumption.

Original: As the graph size increases up to 50, both computational time and the memory consumption of the GT-GAN remains almost constant.
Revised: As the graph size increases up to 50, both computational time and the memory consumption of the GT-GAN remains almost constant.

Original: In contrast, the runtime and memory consumption of RandomVAE and the runtime of GraphVAE increase super-linearly as the graph size increases, making it hard to scale even to a graph size of 50.
Revised: In contrast, the runtime and memory consumption of RandomVAE and the runtime of GraphVAE increase super-linearly as the graph size increases, making it hard to scale even to a graph size of 50.

Original: Interestingly, the runtime and memory consumption of GraphRNN also increases only slightly as the graph size increases.
Revised: Interestingly, the runtime and memory consumption of GraphRNN also increases only slightly as the graph size increases.

Original: However, our GT-GAN model achieves around ten times speedups while requiring almost half of memory, compared to GraphRNN, highlighting the strong linear complexity of GT-GAN in practice.
Revised: However, our GT-GAN model achieves around ten times speedups while requiring almost half of memory, compared to GraphRNN, highlighting the strong linear complexity of GT-GAN in practice.

Original: [Figure]
Revised: [Figure]

Original:  C ONCLUSIONS
Revised:  C ONCLUSIONS

Original: This paper focuses on a new problem: deep graph translation.
Revised: This paper focuses on a new problem: deep graph translation.

Original: To achieve this, we propose a novel
Revised: To achieve this, we propose a novel

Original: GT-GAN which translates an input graph to a target graph.
Revised: GT-GAN which translates an input graph to a target graph.

Original: To learn both global and local mapping between graphs, a new graph encoder-decoder model have been proposed while preserving the graph patterns in various scales.
Revised: To learn both global and local mapping between graphs, a new graph encoder-decoder model have been proposed while preserving the graph patterns in various scales.

Original: Extensive experiments have been conducted on the synthetic and real-world dataset to compare with the state-of-the-art graph generation models.
Revised: Extensive experiments have been conducted on the synthetic and real-world dataset to compare with the state-of-the-art graph generation models.

Original: Experimental results show that our GT-GAN can discover the ground-truth translation rules, and signiﬁcantly outperform other baselines in terms of both effectiveness and scalability.
Revised: Experimental results show that our GT-GAN can discover the ground-truth translation rules, and signiﬁcantly outperform other baselines in terms of both effectiveness and scalability.

Original: This paper opens a thread of research for deep graph translation in many practical applications.
Revised: This paper opens a thread of research for deep graph translation in many practical applications

Original: A M ORE DESCRIPTIONS AND EXPERIMENTS FOR S CALE F REE D ATASET
Revised: A M ORE DESCRIPTIONS AND EXPERIMENTS FOR S CALE F REE D ATASET

Original: Generation of graph pairs .
Revised: Generation of graph pairs .

Original: Each input graph is generated as a directed scale-free network, whose degree distribution follows power-law property Bollobás et al.
Revised: Each input graph is generated as a directed scale-free network, whose degree distribution follows power-law property Bollobás et al.

Original: A node will be selected as target node with probability proportional to its in-degree, which will be linked to a new source node with probability of 0.41.
Revised: A node will be selected as target node with probability proportional to its in-degree, which will be linked to a new source node with probability of 0.41.

Original: Similarly, a node will be selected as source node with probability proportional to its out-degree, which will be linked to a new target node with probability of 0.54.
Revised: Similarly, a node will be selected as source node with probability proportional to its out-degree, which will be linked to a new target node with probability of 0.54.

Original: Then, in the target graph, each weight between two connected nodes will be added by m
Revised: Then, in the target graph, each weight between two connected nodes will be added by m

Original: [Table]
Revised: [Table]

Original: where m could be any value larger than 1.
Revised: where m could be any value larger than 1.

Original: Thus, both input and target graphs are scale-free graphs.
Revised: Thus, both input and target graphs are scale-free graphs.

Original: [Table]
Revised: [Table]

Original: Indirect evaluation and ablation study .
Revised: Indirect evaluation and ablation study .

Original: Other than directly measuring the node degree distribution similarity between the generated and real target graphs, we also conduct an indirect evaluation as done for user authentication dataset.
Revised: Other than directly measuring the node degree distribution similarity between the generated and real target graphs, we also conduct an indirect evaluation as done for user authentication dataset.

Original: Tableshows the average results of graph classiﬁers: Precision, Recall, AUC
Revised: Tableshows the average results of graph classiﬁers: Precision, Recall, AUC

Original: [Table]
Revised: [Table]

Original: and F1-measure for different methods.
Revised: and F1-measure for different methods.

Original: For small graphs (e.g., nodes less then 10), the power-law property of scale-free networks is less obvious compared to the larger size graphs, which may explain why the tasks on smaller scalefree graphs are more difﬁcult.
Revised: For small graphs (e.g., nodes less then 10), the power-law property of scale-free networks is less obvious compared to the larger size graphs, which may explain why the tasks on smaller scalefree graphs are more difﬁcult.

Original: However, when the sizes of graph increase, GT-GAN become more close to the performance of “Gold Standard” with average difference of 10%, 4%, 5% and 9% on F accordingly, and signiﬁcantly outperforms other methods by large margin up to 51%, 35%, 10%, and 19% on F1, respectively.
Revised: However, when the sizes of graph increase, GT-GAN become more close to the performance of “Gold Standard” with average difference of 10%, 4%, 5% and 9% on F accordingly, and signiﬁcantly outperforms other methods by large margin up to 51%, 35%, 10%, and 19% on F1, respectively.

Original: Table 6 shows the ablation study on dataset of
Revised: Table 6 shows the ablation study on dataset of

Original: Scale-III and Scale-IV in both metric evaluation and indirect distribution evaluation.
Revised: Scale-III and Scale-IV in both metric evaluation and indirect distribution evaluation.

Original: [Table]
Revised: [Table]

Original: 2.87 DCNN+decoder 0.
Revised: 2.87 DCNN+decoder 0.

Original: Inf 5.59 Encoder+VGAE 0.
Revised: Inf 5.59 Encoder+VGAE 0.

Original: 49.15 GT-GAN 0.
Revised: 49.15 GT-GAN 0.

Original: Scale-IV
Revised: Scale-IV

Original: GCN+decoder 0.
Revised: GCN+decoder 0.

Original: 18.84 DCNN+decoder 0.
Revised: 18.84 DCNN+decoder 0.

Original: Inf 0.77 Encoder+VGAE 0.
Revised: Inf 0.77 Encoder+VGAE 0.

Original: 43.78 GT-GAN 0.
Revised: 43.78 GT-GAN 0.

Original: Fig.
Revised: Fig.

Original: 9 shows 18 examples of the node degree distribution curve in generated and real target graphs for scale free dataset from size 50 to 150.
Revised: 10 shows 18 examples of the node degree distribution curve in generated and real target graphs for scale free dataset from size 50 to 150.

Original: B D ESCRIPTIONS AND EXPERIMENTS FOR P OISSON R ANDOM D ATASET
Revised: B D ESCRIPTIONS AND EXPERIMENTS FOR P OISSON R ANDOM D ATASET

Original: Generation for graph pairs .
Revised: Generation for graph pairs .

Original: Each input graph is generated by Krapivsky & Redner (2001), which is a directed growing random network.
Revised: Each input graph is generated by Krapivsky & Redner (2001), which is a directed growing random network.

Original: Then for an input graph with E number of edges, we randomly add k E number of edges on it to form the target graph, where k follows the
Revised: Then for an input graph with E number of edges, we randomly add k E number of edges on it to form the target graph, where k follows the

Original: Poisson distribution with the mean of 5.
Revised: Poisson distribution with the mean of 5.

Original: Experiment results .
Revised: Experiment results .

Original: For Poisson random graphs, the distributions of k in the real target graphs and those generated graphs are compared.
Revised: For Poisson random graphs, the distributions of k in the real target graphs and those generated graphs are compared.

Original: The mean of edge increasing ratio k for generated graphs by our GT-GAN is 3.6, compared to the real value of 5, which implies that the GT-GAN generally is able to discover the underlying increasing ratio between input and target graphs.
Revised: The mean of edge increasing ratio k for generated graphs by our GT-GAN is 3.6, compared to the real value of 5, which implies that the GT-GAN generally is able to discover the underlying increasing ratio between input and target graphs.

Original: More evaluation results (e
Revised: More evaluation results (e

Original: [Table]
Revised: [Table]

Original: g. degree and repository) can be found in Appendix B.
Revised: g. degree and repository) can be found in Appendix B.

Original: We draw the probability density curve of the proportion k. Fig.
Revised: We draw the probability density curve of the proportion k. Fig.

Original: 5 shows the distribution of the k in graphs generated by GT-GAN and the real graphs.
Revised: 6 shows the distribution of the k in graphs generated by GT-GAN and the real graphs.

Original: The distribution plot is drew based on 3000 samples.
Revised: The distribution plot is drew based on 3000 samples.

Original: Both of the two distribution have main degree values in the range from 2 to 7, while there is difference in the max frequency due to the limit of the samples amount.
Revised: Both of the two distribution have main degree values in the range from 2 to 7, while there is difference in the max frequency due to the limit of the samples amount.

Original: However, it prove that the proposed GT-GAN do learn the distribution type of translation parameter k in this task.
Revised: However, it prove that the proposed GT-GAN do learn the distribution type of translation parameter k in this task.

Original: Results for indirect evaluation on Poisson Random graphs are listed in Table 7.
Revised: Results for indirect evaluation on Poisson Random graphs are listed in Table 7.

Original: Though the Poisson random task is easier than scale-free graphs, the GT-GAN still outperforms others on AUC and F1, and its performance is highly close to the “Gold Standard”.
Revised: Though the Poisson random task is easier than scale-free graphs, the GT-GAN still outperforms others on AUC and F1, and its performance is highly close to the “Gold Standard”.

Original: Table 8 shows the distance measurement between generated graphs and real graphs in several metrics.
Revised: Table 8 shows the distance measurement between generated graphs and real graphs in several metrics.

Original: For the metric "degree", we use
Revised: For the metric "degree", we use

Original: Wasserstein distances to measure the distance of two degree distribution.
Revised: Wasserstein distances to measure the distance of two degree distribution.

Original: For other metrics, we calculate the MSE between generated graphs and real graphs.
Revised: For other metrics, we calculate the MSE between generated graphs and real graphs.

Original: [Table]
Revised: [Table]

Original: [Table]
Revised: [Table]

Original: C D ESCRIPTION OF IOT DATASET
Revised: C D ESCRIPTION OF IOT DATASET

Original: There are three sets of IoT nodes at different amount (20, 40 and 60) encompassing temperature sensors connected with Intel ATLASEDGE Board and Beagle Boards (BeagleBone Blue), communicating via Bluetooth protocol.
Revised: There are three sets of IoT nodes at different amount (20, 40 and 60) encompassing temperature sensors connected with Intel ATLASEDGE Board and Beagle Boards (BeagleBone Blue), communicating via Bluetooth protocol.

Original: Benign and malware activities are executed on these devices to generate the initial attacked networks as the input graphs.
Revised: Benign and malware activities are executed on these devices to generate the initial attacked networks as the input graphs.

Original: Benign activities include MiBench and
Revised: Benign activities include MiBench and

Original: SPEC2006, Linux system programs, and word processor.
Revised: SPEC2006, Linux system programs, and word processor.

Original: The real target graphs are generated by the classical malware conﬁnement methods: stochastic controlling with malware detection.
Revised: The real target graphs are generated by the classical malware conﬁnement methods: stochastic controlling with malware detection.

Original: D M ORE EXPERIMENTAL RESULTS FOR U SER AUTHENTICATION G RAPH S ET
Revised: D M ORE EXPERIMENTAL RESULTS FOR U SER AUTHENTICATION G RAPH S ET

Original: About Original Dataset
Revised: About Original Dataset

Original: This dataset includes the authentication activities of 97 users on their accessible computers and servers in an enterprise computer network (Kent, 2015).
Revised: This dataset includes the authentication activities of 97 users on their accessible computers and servers in an enterprise computer network (Kent, 2015).

Original: Each user account generates a log ﬁle recording the computer accessing history, which could be formulated as a directed weighted graph called authentication graph, where nodes represent computers and the directed edges weights represent the authentication activities with certain frequencies.
Revised: Each user account generates a log ﬁle recording the computer accessing history, which could be formulated as a directed weighted graph called authentication graph, where nodes represent computers and the directed edges weights represent the authentication activities with certain frequencies.

Original: This data set spans one calendar year of contiguous activity spanning 2012 and 2013.
Revised: This data set spans one calendar year of contiguous activity spanning 2012 and 2013.

Original: It originated from 33.9 billion raw event logs (1.4 terabytes compressed) collected across the LANL enterprise network of approximately 24,000 computers.
Revised: It originated from 33.9 billion raw event logs (1.4 terabytes compressed) collected across the LANL enterprise network of approximately 24,000 computers.

Original: Here we consider two sub dataset.
Revised: Here we consider two sub dataset.

Original: First is the user log-on activity set.
Revised: First is the user log-on activity set.

Original: This data represents authentication events collected from individual Windows-based desktop computers, servers, and Active Directory servers.
Revised: This data represents authentication events collected from individual Windows-based desktop computers, servers, and Active Directory servers.

Original: Another dataset presents speciﬁc events taken from the authentication data that present known red team compromise events, as we call malicious event.
Revised: Another dataset presents speciﬁc events taken from the authentication data that present known red team compromise events, as we call malicious event.

Original: The red team data can used as ground truth of bad behavior which is different from normal user.
Revised: The red team data can used as ground truth of bad behavior which is different from normal user.

Original: Each graph can represent the log-on activity of one user in a time window.
Revised: Each graph can represent the log-on activity of one user in a time window.

Original: The event graphs are deﬁned like this: The node refers to the computers that are available to a user and the edge represents the log-on activity from one computer to another computer of the user.
Revised: The event graphs are deﬁned like this: The node refers to the computers that are available to a user and the edge represents the log-on activity from one computer to another computer of the user.

Original: [Table]
Revised: [Table]

Original: Direct evaluation of User authentication
Revised: Direct evaluation of User authentication

Original: Graph Set .
Revised: Graph Set .

Original: For the user authentication graphs, the real target graphs and those generated are compared under well-recognized graph metrics including degree of nodes, reciprocity, and density.
Revised: For the user authentication graphs, the real target graphs and those generated are compared under well-recognized graph metrics including degree of nodes, reciprocity, and density.

Original: We calculate the distance of degree distribution and Mean Sqaured Error (MSE) for reciprocity and density.
Revised: We calculate the distance of degree distribution and Mean Sqaured Error (MSE) for reciprocity and density.

Original: Table 9 shows the mean square error of the generated graphs and real graphs for all users evaluated for both graph generation methods and ablation models.
Revised: Table 9 shows the mean square error of the generated graphs and real graphs for all users evaluated for both graph generation methods and ablation models.

Original: Case Studies on the generated target graphs .
Revised: Case Studies on the generated target graphs .

Original: Fig.6 shows the example of User 049 with regular activity graph, real malicious activity graph and malicious activity graph generated by our GT-GAN from left to right.
Revised: Fig.7 shows the example of User 049 with regular activity graph, real malicious activity graph and malicious activity graph generated by our GT-GAN from left to right.

Original: Only those of edges with difference among them are drawn for legibility.
Revised: Only those of edges with difference among them are drawn for legibility.

Original: It can be seen that, the hacker performed attacks on Computer 192, which has been successfully simulated by our GT-GAN.
Revised: It can be seen that, the hacker performed attacks on Computer 192, which has been successfully simulated by our GT-GAN.

Original: In addition, GT-GAN also correctly identiﬁed that the Computer 192 is the end node (i.e., with only incoming edges) in this attack.
Revised: In addition, GT-GAN also correctly identiﬁed that the Computer 192 is the end node (i.e., with only incoming edges) in this attack.

Original: This is because GT-GAN can learn both the global hacking patterns (i.e., graph density, modularity) but also can learn local properties for speciﬁc nodes (i.e., computers).
Revised: This is because GT-GAN can learn both the global hacking patterns (i.e., graph density, modularity) but also can learn local properties for speciﬁc nodes (i.e., computers).

Original: GT-GAN even successfully predicted that the hacker connect from Computers 0 and 1, with Computers 7 andas false alarms.
Revised: GT-GAN even successfully predicted that the hacker connect from Computers 0 and 1, with Computers 7 andas false alarms.

Original: For User006 in Fig. 7, the red team attackers make more connections on Nodecompared to user’s regular activity, as marked in red rectangle.
Revised: For User006 in Fig. 8, the red team attackers make more connections on Nodecompared to user’s regular activity, as marked in red rectangle.

Original: GT-GAN leans how to choose the
Revised: GT-GAN leans how to choose the

Original: Node 36 and it generated more connections too in the Node 36.
Revised: Node 36 and it generated more connections too in the Node 36.

Original: E A PPENDIX E: F LOWCHART OF INDIRECT EVALUATION PROCESS
Revised: E A PPENDIX E: F LOWCHART OF INDIRECT EVALUATION PROCESS

Original: Fig.
Revised: Fig.

Original: 8 shows the process of the indirect evaluation process for evaluating whether the generated and the real target graphs follow the same distribution.
Revised: 9 shows the process of the indirect evaluation process for evaluating whether the generated and the real target graphs follow the same distribution.

Original: F A RCHITECTURE P ARAMETER FOR GT-GAN MODEL
Revised: F A RCHITECTURE P ARAMETER FOR GT-GAN MODEL

Original: Graph Translator :
Revised: Graph Translator :

Original: Given the graph size (number of nodes) N of a graph.
Revised: Given the graph size (number of nodes) N of a graph.

Original: The output feature map size of each layer through graph generator can be expressed as:
Revised: The output feature map size of each layer through graph generator can be expressed as:

Original: N
Revised: N

Original: [Equation]
Revised: [Equation]

Original: [Equation]

Original: Discriminator :
Revised: Discriminator :

Original: Given the graph size (number of nodes) N of a graph.
Revised: Given the graph size (number of nodes) N of a graph.

Original: The output feature map size of each layer through graph discriminator can be expressed as:
Revised: The output feature map size of each layer through graph discriminator can be expressed as:

Original: N × N × 1 → N × N × 5 → N × N × 10 → N × 1 × 10 → 1 × 1 ×
Revised: N × N × 1 → N × N × 5 → N × N × 10 → N × 1 × 10 → 1 × 1 ×

Original: For the edge to edge layers, the size of two kernels in two directions are N × 1 and 1 × N .
Revised: For the edge to edge layers, the size of two kernels in two directions are N × 1 and 1 × N .

Original: For the node to edge layer, the kernel size is 1 × N
Revised: For the node to edge layer, the kernel size is 1 × N