Graph Residual Flow for Molecular Graph Generation
Authors: Shion Honda
Hirotaka Akita
Katsuhiko Ishiguro
Toshiki Nakanishi
Kenta Oono
Venue:  (2020)
Keywords: deep generative model
normalizing flow
graph generation
cheminformatics

Abstract: Statistical generative models for molecular graphs attract attention from many researchers from the fields of bio- and chemo-informatics. Among these models, invertible flow-based approaches are not fully explored yet. In this paper, we propose a powerful invertible flow for molecular graphs, called Graph Residual Flow (GRF). The GRF is based on residual flows, which are known for more flexible and complex non-linear mappings than traditional coupling flows. We theoretically derive non-trivial conditions such that GRF is invertible, and present a way of keeping the entire flows invertible throughout the training and sampling. Experimental results show that a generative model based on the proposed GRF achieve comparable generation performance, with much smaller number of trainable parameters compared to the existing flow-based model. 

Under review as a conference paper at ICLR 2020
GRAPH RESIDUAL FLOW FOR MOLECULAR GRAPH GENERATION
Anonymous authors Paper under double-blind review
ABSTRACT
Statistical generative models for molecular graphs attract attention from many researchers from the fields of bio- and chemo-informatics Among these models, invertible flow-based approaches are not fully explored yet. In this paper, we propose powerful invertible flow for molecular graphs, called graph residual flow (GRF). The GRF based on residual flows, which are known for more flexible and complex non non-linear mappings than traditional coupling flows. We theoretically derive non-trivial conditions such that GRF invertible, and present way of keep- ing the entire flows invertible throughout the training and sampling. Experimental results show that generative model based on the proposed GRF achieve compa- rable generation performance, with much smaller number of trainable parameters compared to the existing flow-based model.
INTRODUCTION
We propose deep generative model for molecular graphs based on invertible functions. We especially focus on introducing an invertible function that is tuned for the use in graph structured data, which allows for flexible mappings with less number of parameters than previous invertible models for graphs.
Molecular graph generation is one of the hot trends in the graph analysis with a potential for important applications such as in silico new material discovery and drug candidate screening. Previous generative models for molecules deal with string representations called SMILES (e.g. |Kusner et al.) (217)): 20
et al. (2018). ). which does not consider graph topology. Recent models such as (Jin et al. 2018] You al. 2018 [e Cao Kipf) 2018 Madhawa et al. 2019) are able to directly handle graphs. Several researchers are investigating this topic using sophisticated statistical models such as variational autoencoders (VAEs) (Kingma & Welling 2014), adversarial loss-based models such as generative adversarial networks (GANs) (Goodfellow al. 2014 Radford et al.
2013). and invertible flows (Kobyzev et al. 2019) and have achieved desirable performances.
The decoders of these graph generation models generate discrete graph-structure data from (typically continuous) representation of data sample, which is modeled by aforementioned statistical models. In general, is difficult to design decoder that balances the efficacy of the graph generation and the simplicity of the implementation and training. For example, MolGAN (De Cao & Kipf) (2018) has relatively simple decoder but suffers from generating numerous duplicated graph samples. The state-of-the-art VAE-based models such as (Jin et al. 2018 Liu et al., 2018) have good generation performance but their decoding scheme highly complicated and requires careful training. On the contrary, invertible flow-based statistical models (Dinh et al. 2015) Kobyzev et al. 2019) do not require training for their decoders because the decoders are simply the inverse mapping of the encoders and are known for good generation performances in image generation (Dinh et al.) 2017] Kingma & Dhariwal 2018). [iu al. (2019) proposes an invertible-flow based graph generation model. However, their generative model is not invertible because its decoder for graph structure is not built upon invertible flows. The GraphNVP by MMdhawa et al. (2019) is the seminal fully invertible-flow approach for graph generation, which successfully combines the invertible maps with the generic graph convolutional networks (GCNs, e.g Kipf & Welling (2017); Schlichtkrull et al. (2017))
However, the coupling flow (Kobyzev et al. 2019) used in the GraphNVP has a serious drawback when applied to sparse graphs such molecular graphs we are interested in. The coupling flow

---

Under review as a conference paper at ICLR 2020
requires disjoint partitioning of the latent representation of the data (graph) in each layer. We need to design this partitioning carefully so that all the attributes of a latent representation are well mixed through stacks of mapping layers. However, molecular graphs are highly sparse in general: degree of each node atom is at most four (valency), and only few kind of atoms comprise the majority of the molecules (less diversity). Madhawa et al. (209)) argued that only a specifie form of partitioning can lead to desirable performance owing to sparsity: for each mapping layer, the representation of only one node is subject update and all the other nodes are kept intact. In other words, graph with 100 nodes requires at least 100 layers. But with the 100 layers. only one affine mapping is executed for each attribute of the latent representation. Therefore, the complexity of the mappings of GraphNVP is extremely low in contrast to the number of layer stacks. We assume that this is why the generation performance of GraphNVP is less impressive than other state-of-the-arr models (Jin et al. 2018 Liu et al. 2018) in the paper.
In this paper we propose a new graph flow, called graph residual flow (GRF): a novel combination of generic GCN and recently proposed residual flows (Behrmann et al. 2019 Song et al. 2019 Chen
al. 2019). The GRF does not require partitioning of a latent vector and can update all the node attributes in each layer. Thus, 100 layer-stacked flow model can apply the (non-linear) mappings 100 times for each attribute of the latent vector of the 100-node graph. We derive a theoretical guarantee of the invertibility of the GRF and introduce constraints on the GRF parameters, based on rigorous mathematical calculations. Through experiments with most popular graph generation datasets, we observe that generative model based on the proposed GRF can achieve a generation performance comparable to the GraphNVTH Madhawa et al. (2019), but with much fewer trainable parameters.
To summarize, our contributions in this paper are as follows:
propose the graph residual flow (GRF): a novel residual flow model for graph generation that is compatible with a generic GCNs.
prove conditions such that the GRFs are invertible and present how to keep the entire network invertible throughout the training and sampling.
demonstrate the efficacy of the GRF-based models in generating molecular graphs; in other words, show that a generative model based on the GRF has much fewer trainable parameters compared to the GraphNVP, while still maintaining a comparable generation performance.
2 BACKGROUND
2.1 GRAPHNVP
We first describe the GraphNVP (Madhawa et al. 2019). the first fully invertible model for chemical graph generation, as baseline. We simultaneously introduce the necessary notations for graph generative models.
We use the notation G = X) to represent a graph G comprising an adjacency tensor A and feature matrix X. Let N be the number of nodes in the graph, M be the number of the types of nodes, and R be the number of the types of edges. Then, A E {0, 1] 1 and X E {0, 1 M In the case of molecular graphs, G = (A, X) represents a molecule with types of bonds (single, double, etc.) and M the types of atoms (e.g., oxygen, carbon, etc.). Our objective is to train an invertible model fo with parameters 0 that maps G into a latent point 2 = fo (G) E R (X=(NXXX)++++ (NNM)) We describe fo as a normalizing flow composed of multiple invertible functions.
Let be a latent vector drawn from a known prior distribution p=(=) (e.g., Gaussian): (=()). After applying variable transformation, the log probability of a given graph can be caleulated as:
log (pa (G)) = -log (p)(2) + log (ddel
dz
))
(1)
aG
where aG
0z is the Jacobian of fo at G.
In Madhaaa et al. 2019) fe is modeled by two types of invertible non-volume preserving (NVP) mappings (Dinh et al. (017). The first type of mapping is the one that transforms the adjacency tensor, and the second type is the one that transforms the node attribute X.
2

---

Under review as a conference paper at ICLR 2020
Let divide the hidden variable into two parts za]; the former 2x is derived from invertible mappings X and the latter AA is derived from invertible mappings A. For the mapping of the feature matrix X, the GraphNVP provides node feature coupling:
(e) 2x [e, + 2x (e, exp
6(22 1 (T),)) .)) + 1(=x 1(=x=>1E ,1),,))
where l indicates the layer the coupling. functions & and t stand for scale and translation opera- tions, respectively, and o denotes element-wise multiplication. We use x [6__, to denote latent representation matrix of X' excluding the e row (node). The rest of the rows of the feature matrix remains the same as follows.
[ .]] 2x
(3)
and I. are modeled by a generic GCN, requiring the adjacency information of nodes, A, for better interactions between the nodes.
For the mapping of the adjacency tensor, the GraphNVP provides an adjacency coupling:
Ie, t 2 "I,,, exp (s(2)) (2- (tT,, + (itaf-"(4,,10
(4)
The rest of the rows remain as they are, as follows:
2 ... 2 (e
(5)
For adjacency coupling, we employ simple multi-layer perceptrons (MLPs) for and
The abovementioned formulations map only those variables that are related to node & in each é-th layer (Eqs. 2 and the remaining nodes e are kept intact (Eqs. 3 i.e. the partitioning of the variables always occurs in the first axis of tensors. This limits the parameterization of scaling and translation operations, resulting in reduced representation power the model.
In the original paper, the authors mention: "masking (switching) w.r.t the node axis performs the best. ... We can easily formulate... ... the slice indexing based on the non-node axis ... results in dramatically worse performance due to the sparsity of molecular graph." " Here, sparsity can be described two ways: one is the sparsity non-carbon atoms organic chemicals, and the other is the low degrees of atom nodes (because of valency).
2.2 INVERTIBLE RESIDUAL BLOCKS
One of the major drawbacks the partition- based coupling flow that covers a fairly limited family of mappings. Instead, the coupling flow offers computational cheap and analytic form of inversions. A series of recent invertible models (Behrmann et al. 2019 Song et al. 2019 Chen et al. 2019) propose different approach for invertible mappings, called residual flow (Kobyzev al. 2.19). They formulate ResNets (He et al. 2016). which have been successful in image recognintion, as invertible mappings. The general idea described as follows.
Our objective is to develop an invertible residual layer for a vector 2:
(f+1) 20()) 58 (2())
where z(0) is the representation vector at the éth layer, and P is residual block. If we correctly constrain L, then we can assure the invertibility the above-mentioned residual layer.
i-ResNet (Behrmann et al. 2019) presents a constraint regarding the Lipschitz constant of æ. MintNet (Song et al. 2019) limits the shape of the residual block A and derives the non-singularity requirements of the Jacobian of the (limited) residual block.
Notably, the (invertible) residual connection (Eq. 66) does not assume the partition of variables into "intact" and "afine-mal maffnn-mapp parts. This means that each layer of invertible residual connection updates all the variables at once.
In both the aforementioned papers, local convolutional network architecture (He et al., 2016) of the residual block S is proposed for image tensor inputs, which can be applied for image genera- tion/reconstructions for experimental validations. For example, in i-ResNet, the residual block is
3

---

Under review as a conference paper at ICLR 2020
tmining
Dequantioo (u U10 1))
Resllook FA
ReeBlock F
Denobe
geenation
X
Dequentioe ou U/8 17)
ReSOON Fy
ReOGON
Danokse ....
Figure 1: Overall architecture proposed generative model. During a forward path (encoding), discrete graph components A, X are inputted for dequantization. We apply the proposed GRFs the dequantized components and obtain the latent representations, Za. Zx. During backward path (graph generation), we first apply the inversion the ResBlock Z.. yielding noise-overlapped A', Denoised (recovered) A and Zx are the input arguments for the inverted ResGCN, recovering the noise-overlapped X".
defined as:
1 (x) W3 o W22 o o W1 (x)
where @ denotes a contractive nonlinear function such as ReLU and ELU, W. are (spatially) local convolutional layers (i.e. aggregating the neighboring pixels). In this case, we put constraint that the spectral norms of all Ws are less than unity for the Lipschitz condition.
INVERTIBLE GRAPH GENERATION MODEL WITH GRAPH RESIDUAL FLOW (GRF)
We observe that the limitations of the GraphNVP cannot be avoided as long we use the partition-basee coupling flows for the sparse molecular graph. Therefore we aim realize different type of an invertible coupling layer that does not depend on the variable partitioning (for easier inversion and likelihood computation). For this, we propose new molecular graph generation model based more powerful and efficient Graph Residual Flow (GRF), which is our proposed invertible flow for graphs.
3.1 SETUP
The overall setup is similar to that of the original GraphNVP. We use the notation G = (A, X) to represent a graph G comprising an adjacency tensor A E {0, 1) NxNXR and a feature matrix latent representation through invertible functions. Let
X {0. 1 1.Na Each tensor is mapped ZA E NoVVR be the latent representation of the adjacency tensor, and p (²A) be its prior. Similarly, let 2x TR. NxM be the latent representation of the feature matrix, and (#x) be its prior. We assume that both the priors are multivariate normal distributions.
As A and X originally binary, cannot directly apply the change-of-variable formula. The widely used (Dinh et al., 20177] Kingma & Dhariwal, (2018) Madhawa et al. (019) workaround is dequantization: adding noises drawn from continuous distribution and regarding the tensors as continuous. The dequantized graph denoted as G' = (A'x')) ) is used as the input in Eq.
A' = A cu; w U 1) NXNXR
(8)
X' X + cu; 00, NMM
(9)
where 0 < c 1 is a scaling hyperparameter. We adopted c = 0.9 for our experiment.
Note that the original discrete inputs A and X can be recovered by simply applying floor operation each continuous value A' and X'. Hereafter, all the transformations are performed on dequantized inputs A' and X'.
3.2 FORWARD MODEL
We can instantly formulate naive model, and for doing so, we do not take into consideration the graph structure behind G' and regard A' and X' as simple tensors (multi-dimensional arrays).
4

---

extend the invertible residual blocks of (Behrmann) Under review as a conference paper at ICLR 2020
Namely, tensor entry X'ii, ml is a neighbor of X[t', m'). where |:' - S 1, and Im' - ml - 1, regardless of the true adjacency of node and i', and the feature m and m'. Similar discussion holds for A'.
In such case, we simply apply the invertible residual flow for the tensors A', X'. Let (0) A' and X'
We formulate the invertible graph generation model based on GRFs. The fundamental idea is to replace the two coupling flows in GraphNVP with the new GRFs. A GRF conmprises sub-flows: node feature residual flow and adjacency residual flow.
For the feature matrix, we formulate node feature residual flow for layer e as:
-
(e-1) +
(x((xx x=x (
(10)
where ( a residual block for feature matrix at layer &. Similar to Eq. ( we assume the condition of the adjacency tensor A for the coupling.
For the mapping of the adjacency tensor, have similar adjacency residual flow:
(8) 2 - 2 + +ell (0) ( )
(6-1)
(1I)
where (1() is residual block for adjacency tensor layer l.
Note that there are no slice indices of tensors ZA and Zx in Eqs. 10 11I. Therefore every entry of the tensors is subject to update in every layer, making a notable contrast with Eqs 2
3.3 RESIDUAL BLOCK CHOICES FOR GRFs
One of the technical contributions of this paper is the development of residual blocks for GRFs. The convolution architecture of ResNet reminds us of GCNs (e.g. (Kipf & Welling (0177), inspiring possi- ble application to graph input data. Therefore, cet al. 2019 Song et al. 2019) to the feature matrix and the adjacency tensor conditioned by the graph structure G.
The simplest approach to constructing residual flow model is by using linear layer as layer A. In such cases, we transform the adjacency matrix and feature matrix to single vectors. However, must construct large weight matrix so as not to reduce its dimension. Additionally, naive transformation into vector destroys the local feature of the graphs. To address the aforementioned issues, we propose two types of residual blocks A and Xxx for each of the adjacency matrix and feature matrices.
In this paper, propose residual block based on GCNs (e.g. (Kipf & Welling, 2017 Wu et al.. 2019) for graph-structured data. We focus on modeling the residual block for the node feature matrix.
The original GCN (Kipf & Welling 2017) perform the convolution on graphs using the adjacency information the graph (plus a weight matrix). One layer of the GCN performs the following update of graph node representation zx:
2xxr f o A,.D -.D, #. whereD, = D, + 1, A, +1,
(12) where Ar E NNN is an adjacency matrix of the graph defined by the relation type r, D E NxN a degree matrix: D diag(E, A, W, is the learnable weight matrix for the relation and is nonlinear function. In nutshell, Eq. (2) updates the each node representation in 2x by the weighed sum of neighbor nodes defined by the adjacency tensor Ap.
For our residual blocks on the graph, we replace the convolution filter W in Eq. 7 with Eq 12 to define the neighbors on a graph:
2x (Ex:i) (vee (D, -1/2 D, 1//2 xW.))
(13)
2x (zx) sum, (xx.r),
(14)
Iff entry of D2 is O, then we assume the corresponding entry of D, also
5

---

Under review as a conference paper at ICLR 2020
where vee is vectorize operator, and mat is matrizie operaton. ex appropriately. For Lx defined in this way, the following theorem holds.
Theorem 1. Lip(ø) v I,, 1 Lip 1.
Here, Lip(-) Lipschitz-constant of a certain function. The proof of this theorem provided in appendix.
The Lipschitz constraint not only enables inverse operation (see Section 3.4) but also facilitates the computation of the log-determinant of Jacobian matrix in Eq. ① performed in (Behrmann et al. 2019). other words, the log-determinant of Jacobian matrix can be approximated to the matrix trace (Withers & NNdarajah] 2010), and the trace can be computed through power series iterations Hutchinson 1990).
and stochastic approximation (Hutchinson's 's trick) (Hall 2015
3.4 BACKWARD MODEL OR GRAPH GENERATION
As our model is invertible, the graph generation process is depicted in Fig The adjacency tensors and the feature tensors can simultaneously calculated during training, because their calculations are independent of each other. However, we must note that during generation, valid adjacency tensor is required for the inverse computation of ResGCN. For this reason, we execute the following 2-step generation: first, generate the adjacency tensor and subsequently generate the atomic feature tensor. The abovementioned generation process shown the right half of Fig [ The experiment section shows that this two-step generation process efficiently generate chemically valid molecular graphs.
concat( =A, #x) from prior pz and split the sampled into two, one of which is for zл and the other is for zx- Next, we compute the inverse of =л w.r.t Residual Block by exeed-ooit--itrration Consequently, we obtain a probabilistic adjacency tensor A'. Finally, we construct discrete adjacency tensor A E {0, 1] Nx Nx from A' by taking node-wise and edge-wise argmax operation.
1st step: We sample
2nd step: We consider the discrete matrix À obtained above as a fixed parameter and calculate the inverse image of x for ResGCN using fixed-point iteration. In this way, we obtain the probabilistic adjacency tensor X'. Next, construct discrete feature matrix X {0, 1 1x by taking node wise argmax operation. Finally, we construct the molecule from the obtained adjacency tensor and feature matrix.
3.4.1 INVERSION ALGORITHM: FIXED POINT ITERATION
For the residual layer (= &x)),
generally not feasible to compute the inverse image
analytically. However, we have configured the layer to satisfy Lip(s) ( ) as described above. As was done in the i-ResNet (Behrmann et al. 2019), the inverse image of f(r can be computed using a fixed-point iteration of Algorithm I appendix. From the Banach fixed-point theorem, this iterative method converges exponentially.
3.4.2 CONDITION FOR GUARANTEED INVERSION
From theorem I the upper bound of Lip( L x) is determined by Lip(ø) and || In this work, we selected the exponential linear unit (ELU) as function Φ. ELU is nonlinear function, which satisfies the differentiability condition. By definition, Lip ELU) = 1. For W, the constraints can be satisfied by using spectral normalization (Miyato et al. 2018 The layer Rx configured in this manner holds Lip(Xx) < 1. In other words, this layer is the contraction map. Here, the input can be obtained by fixed point iteration.

---

Under review as a conference paper at ICLR 2020
4 EXPERIMENTS
4.1 PROCEDURE
For our experiments, we use two datasets of molecules, QM9 (Ramakrishnan et al. (014) and ZINC-250K (Irwin et al. 2012). The QM9 dataset contains 134,000 molecules with four atom types, and ZINC-250K is a subset of the ZINC-250K database that contains 250,000 drug-like molecules with nine atom types. The maximum number of heavy atoms in molecule is nine for the QM9 and 38 for the 25NC-250k. As a standard preprocessing, molecules are first kekulized and the hydrogen atoms are subsequently removed from these molecules. The resulting molecules contain only single, double, or triple bonds.
We represent each molecule as adjacency tensor A E {0, NNNNXR and one-hot feature matrix X E {0, 1J. .N denotes the maximum number of atoms molecule in each dataset can have. If molecule has less than N atoms, is padded by adding virtual nodes keep the dimensions of A and X identical. As the adjacency tensors of molecular graphs are sparse, we add virtual bonds, referred as "no bond," between the atoms that do not have a bond.
Thus, an adjacency tensor commprises ==4 adjacency matrices stacked together. Each adjacency matrix corresponds the existence of a certain type of bond (single, double, triple, and virtual bonds) between the atoms. The feature matrix represents the type of each atom (e.g., oxygen, fluorine, etc.). As described in Section 3.3, X and are dequantized to X' and A'.
We use a standard Gaussian distribution A VO. I) as prior distribution (z). The objective function (T) is maximized by the Adam optimizer (Kingma Ba 2013). The hyperparameters are chosen by optuna (Akiba et al., 2019) for QM9 and 250k-250k. Please find the appendix for the selected hyperparameter values. To reduce the model size, we adopt node-wise weight sharing for QM9 and low-rank approximation and multi-scale architecture proposed in (Dinh et al. 2017) for ZINC-250K.
4.2 INVERTIBILITY CHECK
We first examine the reconstruction performance of GRF against the number of fixed- seeddppintt iterations by encoding and decoding 1,000 molccules sampled from QM9 and ZINC-250K. According to Figure 2b the L2 reconstruction error converges around 10-4 after 30 fixed point iterations. The reconstructed molecules are the same as the original molecule after convergence.
4.3 NUMERICAL EVALUATION
Following (Knggma & Dhariwal 2018 Madhawa et al. 2019), we sample 1,000 latent vectors from (emperature-truncaaee normal distribution Ps (2; Tx, Ta) and transform them into molecular graphs by inverse operations. Different temperatures are selected for X and A because they are handled separately in model. We compare the performance of the proposed model with those of the baseline models using the following metrics. Validity (V) is the ratio of the chemically valid molecules the generated graphs. Novelty (N) is the ratio of the molecules that not included in the training set to the generated valid molecules. Uniqueness (U) is the ratio of the unique molecules to the generated valid molecules. Reconstruction accuracy (R) is the ratio of the molecules that are reconstructed perfectly by the model. This metric is not defined for GANs as they do not have encoders.
We choose GraphNVP Madhawa et al., 2019), Junction Tree VAE (JT-VAE) (Jin et al. 2018). Regularizing- VAE (RVAE) (M al. 2018 state-of-the of-the-art baseline models. Also, we choose two additional VAE models as baseline models; grammar VAE(GVAF) (Kusner et al. (017) and character VAE (CVAE) Bombarll et al.) 2018), which learn SMILES((tringg representations of molecules.
We present the numerical evaluation results of QM9 and ZINC-250K datasets on the Table I (M99) and the Table (ZINC-250K), respectively. As expected, GRF achieves 100% reconstruction rate, which is enabled by the ResNet architecture with spectral normalization and fixed fixed-point iterations. This has never been achieved by any other VAE-based baseline that imposes stochastic behavior in the bottleneck layers. Also, this is achieved without incorporating the chemical knowledge, which is done in some baselines (e.g., valency checks for chemical graphs in RVAE and GVAE, subgraph
7

---

Under review as a conference paper at ICLR 2020
Bermalized 12 reconstuccion orrer
ZINC-250K
Original
RecondAruzee
107
qm3
10
10-1
20
10-4
10
10
0
20
40
60
80 100
Iterations
(a) Reconstruction error.
(b) Original and reconstructed molecules.
Figure 2: (a) L2 reconstruction etror of GRF against the number of fixed-point iterations. L2 errors are measured between dequantized A', X' and reconstructed A', X', normalized by the number of entries. We observe that the error decays exponentially with the number of iterations in both datasets. (b) The original and reconstructed molecules sampled from QM9 and ZINC-250K with 100 fixed fixed-point iterations. The color maps depict the values the dequantized feature and adjacency matrices. Feature matrices have single channel while adjacency matrices have three channels excluding the virtual bond channel and are visualized as RGB channels. Because the values are to be quantized by argmax function over each node and the noise scaling hyperparameter is set as 0.9. if at any pixel the value difference is less than 0.1, the molecule is accurately reconstructed.
vocabulary in JTT-VA), This is preferable because additional validity checks are computationally demanding, and the prepared subgraph vocabulary limits the extrapolation capacity the generative model. As our model does not incorporate domain-specific procedures, it can be easily extended to general graph structures.
It is remarkable that our GRF-based generative model achieves good generation performance scores comparable to GraphNVP, with much fewer trainable parameters in order of magnitude. These results indicate the efficient construction of our GRF in terms of parametrization. as well as powerfulness and flexibility of the residual connections, compared to the coupling flows based on simple affine transformations. Therefore, our goal of proposing a novel and strong invertible flow for molecular graph generation successfully achieved by the development of the GRE We will discuss the number of parameters of GRF using Big-O notation in Section 4.4.
The experiments also reveal a limitation of the current formulation of the GRE, One notable limi- tation is the lower uniqueness compared to the GraphNVP. We found that the generated molecules contain many straight-chain molecules compared to those of GraphNVP, by examining the generated molecules manually. We attribute this phenomenon the difficulty of generating realistic molecules without explicit chemical knowledge or autoregressive constraints. We are planning to tackle this issue as of the future works.
4.4 EFFICIENCY IN TERMS OF MODEL. SIZE
As we observe in the previous section, our GRF-based generative models are compact and memory- efficient in terms of the number of trainable parameters, compared to the existing GraphNVP flow model. In this section we discuss this issue in more formal manner.
Let be the number of layers, R be the number of the bond types, M be the number of atom types. For GraphNVP, We need O (LN' Rº)) and O (LN" 2 R²) parameters to construct adjacency coupling layers and atom coupling layers, respectively. From the above, need O (LN' (N22 + M²) parameters to construct whole GraphNVP. By contrast, our model only requires O (LR2N2) and O (LR² M²) parameters for res- essGGrahhLinear and res-GCN, respectively. Therefore, whole GRF model requires O (N2 + +M2) parameters. most cases of molecular graph generation settings, R and N is dominant."
8

---

Under review as a conference paper at ICLR 2020
Table Performance generative models with respect quality metrics and numbers of their parameters for QM9 dataset. Results of GraphNVP are recomputed following the hyperparameter setting in the original paper. Other baseline scores are borrowed from the original papers. Scores of GRF are averages over 5 runs. Standard deviations are presented below the averaged scores. We use 7x 0.65 and T 0.69 for QM9.
Method
%
% N
% U
%
Params
84.5
58.6
66.0
GRF
100.0
56,120
(= 0.70)
(# 0.82)
(#: 1.15)
GraphNVP
90.1
54.0
97.3
100.0
6,145,831
RVAE
96.6
97.5
61.8
GVAE
60.2
80.9
9.3
96.0
CVAE
10.3
90.0
67.5
3.6
Table Performance of generative models with respect quality metrics and numbers of their parameters for ZINC-250K dataset. Results of GraphNVP and JT- VAE are recomputed following the hyperparameter setting in the original paper. Other baseline scores are borrowed from the original papers, Scores of GRF are averages over 5 runs. Standard deviations presented below the averaged scores. We use T' 0.15 and l' 0.17 for 7INC-250k.
Method
% V
% N
% U
% R
# Params
73,4
100.0
53.7
GRF
100.0
3,234,552
(:: 0.62)
(+: 0.0)
(#: 2.13)
GraphNVP
77.3
100.0
94.8
100.0
245,792,665
JT-VAB
99.8
100.0
100.0
76.7
RVAE
34.9
100.0
54.7
GVAE
7.2
100.0
9.0
53.7
CVAE
0.7
100.0
67.5
44.6
Our GRF for ZINC-250K uses linear layers to handle adjacency matrices, but the number of the parameters is substantially reduced by low-rank approximation (introduced in Sec. 4.1). Let be the approximated rank of each linear layer, and the whole GRF requires only O (LR (N2r+ M²)) parameters. Notably, GraphLinear is equal to low-rank approximation when r 1.
Our model's efficiency in model size is much more important when generating large molecules. Suppose want generate molecule with N 100 heavy atoms with batch size of 64. Estimating from the memory usage of GRF for ZINC-250k (N = 40), GRF will consume 21 GB if = 100 and GraphNVP will consume as large 2100 GB. Since example of the GPUs currently used (e.g., NVIDIA Tesla V100) is equipped with 166-3 32 GB memory, GraphNVP cannot process a batch on a single GPU or batch normalization becomes unstable with small batch. On the other hand, our model will scale to larger graphs due to the reduced parameters.
4.5 SMOOTHNESS OF THE LEARNED LATENT SPACE
As a final experiment, we present the visualization of the learned latent space of Z. First randomly choose 100 molecules from the training set, and subsequently encode them into the latent representation using the trained model. We compute the first and the second principal components of the latent space by principal component analysis (PCA), and project the encoded molecules onto the plane spanned by these two principal component vectors. Then we choose another random molecule, To encode it and project it onto the aforementioned principal plane. Finally we decode the latent points on the principal plane, distributed in a grid-mesh pattern centered at the projection of xi and visualize them in Fig. Figure 3 iindicates that the learnt latent spaces from both QM9 (panel (a)) and ZINC-250K datasets (panel (b)) are smooth where the molecules gradually change along the two axes.
The visualized smoothness appears to be similar to that of the VAE-based models but differs that GRF is bijective function: the data points and the latent points correspond to each other in one-to-one manner. In contrast, to generate the data points with VAE-based methods, it required decode the same latent point several times and select the most common molecule. Our model is

---

Under review as a conference paper at ICLR 2020
efficient because it can generate the data point in one-shot. Additionally, smooth latent space and bijectivity are crucial to the actual use case. Our model enables molecular graph generation through querying: encode molecule with the desired attributes and decode the perturbed latents to obtain the drug candidates with similar attributes.
rs gaiod doree
aann na fnr gaad 2o
for for yor
(a)
(b)
Figure 3: Visualization learned latent spaces along the first and second principal components. The empty space in the grid indicates that an invalid molecule is generated.
5 CONCLUSION
In this paper, we proposed Graph Residual Flow, which is an invertible residual flow for molecular graph generations. Our model exploits the expressive power of ResNet architecture. The invertibility of our model is guaranteed only by slight modification, i.e. by the addition of spectral normalization each layer. Owing to the aforementioned feature, our model can generate valid molecules both in QM9 and ZINC-250k datasets. The reconstruction accuracy is inherently 100%, and our model is more efficient in terms of model size as compared to GraphNVP, a previous flow model for graphs. In addition, the learned latent space of GRF is sufficiently smooth to enable the generation of molecules similar to a query molecule with known chemical properties.
Future works may include the creation of adjacency residual layers invariant for node permutation, and property optimization with GRF.
REFERENCES
Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. Optuna: A next- generation hyperparameter optimization framework. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD '19, pp. 2623-2631. ACM, 2019.
Jens Behrmann, Will Grathwohl, Ricky Q. Chen, David Duvenaud, and Jörn-Henrik Jacobsen. Invertible residual networks. Proceedings of Incerntional Conference on Machine Learning (ICML), 2019.
Ricky T. Q. Chen, Jens Behrmann, David Duvenaud, and Jörn-Henrik Jacobsen. Residual flows for invertible generative modeling, arXiv preprint 1xXiv:1906.0275: 2019.
Nicola De Cao and Thomas Kipf. Molgan: An implicit generative model for small molecular graphs.
arXiv preprint arXiv: 105. 1973, 2018.
Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: Non-linear independent components estimation. In Proceedings of the International Conference on Learning Representations (ICLR), 2015.
10

---

Under review as a conference paper at ICLR 2020
Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nyp. In Proceedings of International Conference on Learning Representations (ICLR), 2017. URL
htttps://axii.. org/ wtwpg//////i....e. 1605. 08803
Rafael Cómezz-ombaarell,, Jennifer N Wei, David Duvenaud, José Miguel Heráández-Lobaee Benjamín Sinnhez-Lengelinn Dennis Sheberla, Jorge Aguilera-Iparae Iparraguirre, Timothy D Hirzel, Ryan P Adams, and Alán Aspuru-Guzik, Automatic chemical design using data-driven continuous representation of molecules. ACS central science, 4(2):268-22) 276, 2018.
Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farles Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672-2680, 2014.
Brian Hall. Lie groups, Lie algebras, and representations: an elementary introduction, volume 222. Springer, 2015.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
Michael F Hutchinson. stochastic estimator of the trace of the influence matrix for laplacian smoothing splines. Communications in 1990.
and Computation, 19(2):433 450,
John J Irwin, Teague Sterling, Michael M Mysinger, Erin S Bolstad, and Ryan Coleman. Zinc: a free tool discover chemistry for biology. Journal of chemical information and modeling, 52(7): 1757-1768, 2012.
Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 2332-2332, Stockholmsmässan, Stockholm Sweden, 10-15 Jul 2018. PMLR. URL http://proceeddnng mlr. press /80/ 1in Ba. html
Diederik P. Kingma and Jimmy Lei Ba. Adam: a Method for Stochastic Optimization. Proceedings of the International Conference on Learning Representations (ICLR), 2015.
Diederik P Kingma and Max Welling, Auto-encoding variational bayes. In Proceedings of the 2nd International Conference on Learning Representations (ICLR), 2014. URL htttt::////aaa
htt//bbs/1333 6114
Durk Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In Advances in Neural Information Processing Systems, pp. 10236- 10245. Curran Associates, Inc., 2018. URL /tttps://ppprs..tttt wttp:rss.iis..cc...eeee
Thomas N. Kipf and Max Welling. Semi-supervised Classification with Graph Convolutional Net- works. In Proceedings of the 5th International Conference on Learning Representations (ICLR), 2017.
Ivan Kobyzev, Simon Prince, and Mareus A Brubaker. Normalizing Flows: Introduction and Ideas. arXIv, pp. 1908.09257 [cs. 2019.
Matt J Kusner, Brooks Paige, and José Miguel Hernández-Lobato. Grammar variational autoencoder. In Proceedings of the 34th International Conference on Machine cearning-Volume 70, pp. 1945- 1954. PMLR, 2017.
Jenny Liu, Aviral Kumar, Jimmy Ba, Jamle Kiros, and Kevin Swersky. Graph normalizing flows. arXiv preprint arXiv: 1 1905.1 1.0..13177 13777, 2019.
Qi Liu, Miltiadis Allamanis, Mare Brockschmidt, and Alexander Gaunt. Constrained graph variational autoencoders for molecule design. In Advances in Neural Information Processing Systems, pp. 7806-7815,201
11

---

Under review as a conference paper at ICLR 2020
Tengfei Ma, Jie Chen, and Cao Xiao. Constrained generation of semantically valid graphs via regularizing variational autoencoders. In Advances in Neural Information Processing Systems, pp. 7113-7124, 2018.
Kaushalya Madhawa, Katushiko Ishiguro, Kosuke Nakago, and Motoki Abe. Graphnyp: An invertible flow model for generating molecular graphs. arXiv preprint arXiv: (tt::1905.11 1600, 2019.
Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. In International Conference on Learning Representations, 2018.
URL / www.://wnneeeeooondnddddd---de
Kenta Oono and Taiji Suzuki. On asymptotic behaviors of graph enns from dynamical systems perspective, 2019.
Alec Radford, Luke Metz. and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In Proceedings of International Conference on Learning Representations (ICLR), 2015.
Raghunathan Ramakrishnan, Pavlo O Dral, Matthias Rupp, and O Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific data, 1:140022, 2014.
Michael Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van den Berg. Ivan Titov, and Max Welling. Modeling Relational Data with Graph Convolutional Networks. arXiv, pp. 1703.061034 [s.a 2017.
Yang Song, Chenlin Meng, and Stefano Ermon. Mintnet: Building invertible neural networks with masked convolutions, arXiv preprint arXiv:1907.07945, 2019.
Christopher S Withers and Saralees Nadarajah. log det a= tr log a. International Journal of Mathematical Education in Science and Technology, 12(9):111 2010.
Felix Wu, Tianyi Zhang, Amauri Jr. Holanda de Souza, Christopher Fifty, Tao Yu, and Kilian Q Weinberger. Simplifying Graph Convolutional Networks. Proceedings the 36th International Conference Machine Learning (ICML), 2019.
Jiaxuan You. Bowen Liu, Zhitao Ying, Vijay Pande, and Jure Leskovec. Graph convolutional
policy network for goal-directed molecular graph generation. In Advances in Neural Information Processing Systems, pp. 6412-6423 2018.
12

---

Under review as a conference paper at ICLR 2020
A PROOF OF THEOREM
Lemma 1, VA "ARRN V X((= (21,..,,, E RNxd s.t. ||XX| - ||Allop F
Proof.
N
|AX
Σ
||r
$ || op Σ
|
|| | 2
:. ||AX] F - ||
|
Lemma 2. ||Pllpp 1- AD
I 1.
Proof. Augmented Normalized Laplacian L is defined L = ----'" 1/2 normal graph Laplacian, an i-th eigenvalue ãı, L holds 0 S Ar S. 2 (Oono & Suzuki 2019 Here, for the eigenvector corresponding to A which is the i-th eigenvalue of P:
P. Like the
Pv; A
U/ Lu; A,4
Lus =(1 -1- As)yu
\ == jrs.
-1 As 5 maximum singular value (P). As P symmetric matrix from its construction, the maximum singular value a (P) is equal to the absolute eigenvalue /Amax with the largest absolute value. From these conditions, Plap I (P) Amaxl 1.
S l.c. A < follows. Here, operation norm ||Pll is bounded
1 + (ip <1 T,
Theorem 1. Lip(0) 2 L, W
<
Proof. [xx(x) Bx(1)ll2 = |1 (vec (PXW)) - 6 (vee (PYW))
< L [Ivec (PXW) vec (PYW)
(: Lip(ø) I L)
L|PPX PYW
- -Y)
< <L|PP 1(x -X) -Y)WIlF
(:: Lemma 2.)
< L <L11(X-1 -Y)
(: Lemma 1.)
$ L ||X Y
1
< T, |X-XII
< |X -YllF
= |ivec (X) - vec (Y)
||0 v112.
Lip(
13

---

Under review as a conference paper at ICLR 2020
Algorithm I Inverse of Residual-layer via fixed-point iteration.
Input: output from residual layer y, contractive residual block A, number of iterations Output: inverse of y w.r.t
Zo y for 1 = , do
2++11 yy 90 (x4) end for return Z'y.
B MODEL HYPERPARAMETERS
use a single-scale architecture for QM9 dataset, while we use multi-scale architecture (Dinh et al., 2017) for ZINC-250K dataset to scale to 38 heavy atoms. Other hyperparameters are shown in Table We find the factor of spectral normalization 0.9 enough for numerical invertibility.
Table 3: Model hyperparameters for QM9 and ZINC250K. BS and LR stand for batch size and learning rate,
respectively.
Dataset
GCN blocks
GCN layers
MLP blocks
ML.P layers
BS
L.R
Epochs
QM9
32
25
2048
1e-3
70
ZINC-250K
3
256
le-4
70
C ALGORITHMS
We show procedure to calculate inverse of with reference to A in algorithm 1 In experiments, we chose 100 number of iteration n.
14


Reviews:
[{"review_id": "rkxxhCD0YH", "reviewer": "AnonReviewer2", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "The paper introduces an invertible deep generative model architecture for modeling molecular graphs. The model is based on graph residual flows (GRF), which is a graph variant of normalizing flows. The GRF model is a refinement of the GraphNVP generative model, which is also invertible,  but which does not seem to work very well for sparse low-degree graphs (such as molecular graphs). \n\nThe main new idea seems to be to replace the regular coupling flows of GraphNVP with residual blocks: the residual blocks ensure invertibility while also helping to \"mix\" the information in the (tensor) representations in each layer better. This leads to more compact generative models. Due to the residual structure of the encoding model, the inversion (backward mapping) is a bit more expensive since it requires solving a fixed point problem in each layer, but in principle it can be done provided the layer weight matrices have small spectral norm.\n\nExperimental results on two molecular datasets seem to confirm the validity of the proposed architecture.\n\nThe paper is nicely written and the techniques/results are clearly described. However, I have two main concerns:\n\n- Conceptual novelty seems to be limited. The method seems to be a basic modification of the GraphNVP approach by introducing ResNet-like skipped connections. Not entirely sure if this counts as a major contribution. \n- Experimental results do not seem to suggest improvements over the state of the art. I am not an expert in molecular generation, but looking at Tables 1 and 2 seem to suggest that the smaller number of parameters in GRF (compared to GraphNVP) come with dramatically reduced performance measures pretty much across the board. This seems like a weak result So I do not know whether the tradeoffs are worth it or not.\n\nOther comments:\n- The detailed pseudocode of Algorithm 1 isn't really necessary considering it is just a fixed point iteration.\n- Unclear why the reconstruction error in Fig 2 does not monotonically decrease for the ZINC dataset.\n- Unclear why Fig 3 suggests smooth variations in the learned latent spaces. I can only spot mode collapses and sudden jumps. It might help to plot VAE/GraphNVP embeddings here too.\n\n", "extra_scores": {"experience_assessment": "I have read many papers in this area.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper at least twice and used my best judgement in assessing the paper.", "review_assessment:_checking_correctness_of_experiments": "I assessed the sensibility of the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I assessed the sensibility of the derivations and theory."}, "extra_text": {}}, {"review_id": "HygVaGssYH", "reviewer": "AnonReviewer3", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "Summary:\n\nThe paper proposes a flow-based model for generating molecules, called Graph Residual Flow (GRF). GRF is a version of iResNet that is tailored to molecule generation. The experiments show that GRF achieves similar performance to GraphNVP (a previous flow-based model for molecule generation), but has about 100 times fewer parameters.\n\nDecision:\n\nThis is interesting work, but in my opinion the current version of the paper needs significant improvement. For this reason, my recommendation is weak reject.\n\nContribution & originality:\n\nI think the application of flow models to the generation of molecules is an interesting research direction. Since molecules are structured objects that can be represented as graphs of connected atoms, care has to be taken to design suitable generative models for them, and this paper is a step in this direction.\n\nThe proposed model (GRF) is similar to iResNet in most aspects. The main differences are:\n- The linear layers in iResNet are modified to take into account the connectivity of the molecule.\n- Separate networks are used to generate the adjacency tensor and the feature matrix. The adjacency tensor is generated first, and then the feature-matrix network is conditioned on the generated adjacency matrix.\nOther than the above, GRF is a straightforward application of iResNet in molecule generation.\n\nTechnical & writing quality:\n\nThe experiments are interesting, and GRF is shown to perform similarly to GraphNVP while using 100 times fewer parameters. The comparison between GRF and GraphNVP is in my opinion the most interesting part of the paper. The experiments that show GRF can reconstruct molecules exactly and that generated molecules are a smooth function of the latent variables are less interesting in my opinion; exact invertibility and smoothness are inherent properties of flow-based models that exist by design, so there isn't anything surprising about them.\n\nThe main issue with the paper is that it's poorly written. In my opinion, the writing quality of the paper needs significant improvement for the paper to qualify for publication. The model is explained very poorly; if I weren't already familiar with iResNet I don't think I would be able to understand the model and be able to reproduce the results by reading the paper. Moreover, the use of English throughout the paper is poor: there are a lot of grammatical mistakes (such as incorrect usage of articles or lack of subject-verb agreement), and awkward expressions. In the following I will do my best to make concrete suggestions for improvement, but I would strongly encourage the authors to revise the paper thoroughly and have it checked for grammar and writing quality.\n\nSuggestions for improvement:\n\n\"The decoders of these graph generation models generates\" --> generate\n\n\"The state-of-the-art VAE-based models [...] have good generation performance but their decoding scheme is highly complicated\"\nIn what way is it complicated? Please provide more details.\n\n\"invertible flow-based statistical models [...] does\" --> do\n\n\"[flow-based models don't] require training for their decoders because the decoders are simply the inverse mapping of the\nencoders\"\nThis is an odd and unusual description of flow-based models. The way I see it, flow-based models aren't autoencoders, but functions that reparameterize data (here molecules) in terms of simpler random variables (here Gaussian noise). Saying that flow-based models don't require training for their decoders makes little sense.\n\n\"Liu et al. (2019) proposes\" -->  propose\n\n\"GraphNVP has a serious drawback when applied for sparse graphs\" --> applied to sparse graphs\n\n\"only one affine mapping is executed for each attribute of the latent representation\"\nThere are also coupling layers that are non-affine and therefore more flexible. For example:\n- Neural Autoregressive Flows, https://arxiv.org/abs/1804.00779\n- Sum-Of-Squares Polynomial Flow, https://arxiv.org/abs/1905.02325\n- Neural Spline Flows, https://arxiv.org/abs/1906.04032\n\n\"show that a generative model based on the GRF has much fewer trainable parameters compared to the GraphNVP, while still maintaining a comparable generation performance\"\nIf GRF can achieve a performance similar to GraphNVP with fewer parameters, shouldn't it be able to achieve much better performance with more parameters? If this is true, I would have expected to see an experiment were GRF uses more parameters and as a result outperforms GraphNVP. If GRF doesn't outperform GraphNVP even with more parameters, then I would expect to see a discussion explaining why.\n\nit would be good to explain fully the format of the data as early as in section 2.1. For example, it wasn't clear to me until much later how a flow-based model can be applied to discrete data, and whether the rows of the adjacency tensor and feature matrix are one-hot or not. Currently, the format of the data is partially explained three times (in section 2.1, section 3.1 and section 4.1) and only in section 4.1 things become clear for the reader.\n\nBeginning of page 3: the dequantized matrix X' is used before having been defined. This is an example of why the format of the data should be fully explained early on.\n\n\"The abovementioned formulations map only those variables [..] (Eqs.(2,5), and the remaining nodes [..] (Eqs.(3,5)\"\nThe first reference should be Eqs. (2,4). Also, the parentheses should close.\n\n\"ResNets [...], the golden standard for image recognition\"\nThe expression is \"gold standard\" not \"golden standard\". Also, it's too strong a statement and rather subjective to say that ResNets are the gold standard for image recognition; better say that ResNets have been successful in image recognition, which is an accurate and objective statement.\n\nSection 2.2 introduces iResNets, but it doesn't explain clearly that making the residual block contractive is a sufficient condition for invertibility. This is a crucial element for understanding iResNet that is used later on in the paper, so it should be clearly explained early on.\n\n\"i-ResNet [...] presents a constraint regarding the Lipschitz constant\"\nToo vague, and it doesn't explain what the constraint is.\n\n\"MintNet [...] derives the non-singularity requirements of the Jacobian of the (limited) residual block\"\nAlso vague and not informative.\n\nBeginning of section 3: GraphMVP --> GraphNVP\n\n\"we cannot directly apply the change-of-variables formula directly\"\nUses \"directly\" twice.\n\n\"we do not take it consideration\" --> we do not take into consideration\n\n\"an tensor entry X'[i, m] is a neighborhood\" --> a tensor entry X'[i, m] is a neighbor\n\n\"Similar discussion holds for A'\"\nIt's unclear to me what exactly holds for A', please be more specific. The previous statement mentioned neighbours, how does this apply to A'?\n\nIn the text after eq. (10), R_X uses a different font.\n\n\"is subject to update in every layers\" --> in every layer\n\nSection 3.3. is particularly poorly written. Given that this is one of the main contributions of the paper, it is really important that this section is written well and clearly. Currently, the section contains two one-sentence paragraphs that are clearly out of place. Also, eq. (12) makes little sense. In particular:\n- Isn't A a tensor of shape NxNxR? How did it become a matrix?\n- In what sense is X a matrix representation of z_x? How is X computed? Shouldn't X be of shape NxM? Also, please use a different symbol other than X, as X is already used for the feature matrix.\n- What is D and how is it defined?\n- Is vec() the vectorization operator? Does that mean that the input and output to the residual block has been flattened? This has not been explained or mentioned anywhere.\n- Is W a fully-connected linear layer or a convolution as in iResNet?\n- Where did the term D^{-0.5} A D^{-0.5} come from? How is it motivated / derived? Why does it make sense to use it? I understand that it's related to the graph Laplacian, but more information is needed for readers who are not familiar with graphs.\n\n\"is a Lipschitz-constant of for a certain function\" --> of a certain function\n\nThe explanation of eq. (13) is very poor, and I don't think a reader who is not already familiar with iResNet can follow it. Also, how was the infinite sum approximated? Did you use truncation or the Russian-roulette estimator?\n\nSection 3.4 introduces the term \"atomic feature tensors\" which is not defined. I presume it's the same as the feature matrix. Please be consistent with terminology throughout the paper.\n\n\"adjacent tensor\" --> adjacency tensor\n\n\"we have configure\" --> configured\n\nSection 3.4.2 finally explains the invertibility condition. Clearly, this is an important element of the algorithm, and should be explained fully and clearly early on. By this point, the invertibility condition should be clear, and no further explanation should be needed.\n\n\"we selecte\" --> selected\n\n\"satisfies the differentiability\" --> \"satisfies the differentiability condition\", or even better \"is differentiable\"\n\nWhat does \"kekulized\" mean?\n\n\"conmprises\" --> comprises\n\n\"we adopt node-wise weight sharing for QM9 and low-rank approximation and multi-scale architecture\"\nThese are important aspects of the architecture that are nowhere else mentioned, and should be explained more thoroughly.\n\n\"p_z(T_X, T_A; z)\"\nShouldn't this be p_z(z; T_X, T_A)?\n\nWhat does \"unique molecules\" mean? Are they the molecules that don't exist in the data? How do they differ from \"novel molecules\"?\n\nIt would be good to provide additional results. In particular:\n- It would be good to report training/validation/test log likelihood, or learning curves, that compare between GRF and GraphNVP.\n- It would be good to show how the metrics V, N, U, R in tables 1 and 2 vary with respect to the temperatures (for example, show curves of the four metrics as temperatures vary). Currently, results are reported for only one setting of temperatures, which doesn't show how sensitive the performance is to the temperatures.\n\nThe temperatures for ZINC-250k are really low (0.15 and 0.17), which to me is an indication that the flow model may have fitted the data quite badly.\n\nHow does GRF compare to GraphNVP in terms of generation time? How slow is it to generate from GRF given that it takes 30 iterations for each residual block?\n\nWhat is GraphLinear? Maybe give a citation?\n\n\"Since one of the most GPUs currently used\"\nThis phrase doesn't make much sense.\n\n\"principle components analysis\" --> principal components analysis\n\"Principle\" has a different meaning from \"principal\".\n\nFigure 3: Wouldn't it be more informative to centre the visualizations at the mean and use the two principal axes, rather than random mean and axes?", "extra_scores": {"experience_assessment": "I have published one or two papers in this area.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I carefully checked the derivations and theory.", "review_assessment:_checking_correctness_of_experiments": "I carefully checked the experiments.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper thoroughly."}, "extra_text": {}}, {"review_id": "Byg02cl9cS", "reviewer": "AnonReviewer1", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "GraphNVP is the first paper to introduce the concept of \"invertible flow\", that is to construct the invertible mapping from latent vector z to the graph G. By constructing the mapping from G to z, GraphNVP first changes the discrete feature vector into continuous variables, then update this matrix representation by scaling and transforming functions (Eq. (2)-(5) in this GRF paper). In each iteration the matrix is only updated by one row (one slice for the tensor), while keep other rows intact. Then for constructing the inverse mapping, we can first sample a random vector and then apply the “inverse” of the update rule to recover the edge matrix and node matrix respectively.\n\nThe main contribution for GRF paper is to find a new update rule from the idea of ResNet. The author thinks that GraphNVP only update one row each time, which is less efficient, and the model can only cover a limited number of mappings. Then he proposed a new function for update (Eq. (6)-(7)), which updates all rows each time. The author shows how to approximate the determinant of the Jacobian matrix, and how to construct the inverse mapping from fixed-point iteration, as the mapping is Lipschitz. Lastly the author shows that GRF uses much less parameters than GraphNVP both theoretically and practically, which means that the new model is more expressive. However, the new model may output the same molecule for several times (shown by “Uniqueness\"), and it favors the striaght-chain molecules.\n\nAnother question related to the experiment is that how does the method compared to methods which first generate SMILES string and then convert to molecule graph? Eg. Dai Et al. ICLR 2018, Syntax-directed generative model for structured data. ", "extra_scores": {"experience_assessment": "I have published one or two papers in this area.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I assessed the sensibility of the derivations and theory.", "review_assessment:_checking_correctness_of_experiments": "I assessed the sensibility of the experiments.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper at least twice and used my best judgement in assessing the paper."}, "extra_text": {}}]

Author rebuttal:

Meta-review: The authors propose a graph residual flow model for molecular generation.  Conceptual novelty is limited since it is simple extension and there isn't much improvement over state of art.
Decision: Reject