Original: DEFactor: Differentiable Edge Factorization-based Probabilistic Graph Generation
Revised: DEFactor: Differentiable Edge Factorization-based Probabilistic Graph Generation

Original: Anonymous authors
Revised: Anonymous authors

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

Original: Abstract
Revised: Abstract

Original: Generating novel molecules with optimal properties is a crucial step in many industries such as drug discovery.
Revised: Generating novel molecules with optimal properties is a crucial step in many industries such as drug discovery.

Original: Recently, deep generative models have shown a promising way of performing de-novo molecular design.
Revised: Recently, deep generative models have shown a promising way of performing de-novo molecular design.

Original: Although graph generative models are currently available they are either computationally expensive, limiting their use to only small graphs or are formulated as a sequence of discrete actions needed to construct a graph, making the output graph non-diﬀerentiable w.r.t the model parameters, therefore preventing them to be used in scenarios such as conditional graph generation.
Revised: Although graph generative models are currently available they are either computationally expensive, limiting their use to only small graphs or are formulated as a sequence of discrete actions needed to construct a graph, making the output graph non-diﬀerentiable w.r.t the model parameters, therefore preventing them to be used in scenarios such as conditional graph generation.

Original: In this work we propose a model for conditional graph generation thatis computationally cheap, scalable, directly optimises properties of the graph, and generates a probabilistic graph, making the  process diﬀerentiable, thus enabling end-to-end training with stochastic gradient descent.
Revised: In this work we propose a model for conditional graph generation that directly optimises properties of the graph, and generates a probabilistic graph, making the decoding process diﬀerentiable, thus enabling end-toend training with stochastic gradient descent.

Original: We demonstrate favourable performance of our model on prototype-based molecular graph conditional generation tasks.
Revised: We demonstrate favourable performance of our model on prototype-based molecular graph conditional generation tasks.

Original:  Introduction
Revised:  Introduction

Original: In this paper we address the problem of learning probabilistic and diﬀerentiable generative graph models for tasks such as prototype-based conditional sampling of molecules with optimal properties.
Revised: In this paper we address the problem of learning probabilistic and diﬀerentiable generative graph models for tasks such as prototype-based conditional sampling of molecules with optimal properties.

Original: More precisely we focus on generating realistic molecular graphs, similar to a target molecule (the prototype) and whose attributes can be controlled or optimised.
Revised: More precisely we focus on generating realistic molecular graphs, similar to a target molecule (the prototype) and whose attributes can be controlled or optimised.

Original: The main challenge stems from the discrete nature of molecules.
Revised: The main challenge stems from the discrete nature of molecules.

Original: This particularly prevents us from using global discriminators that assess generated samples and back-propagate their gradients to guide the optimisation of the generator.
Revised: This particularly prevents us from using global discriminators that assess generated samples and back-propagate their gradients to guide the optimisation of the generator.

Original: This becomes very important in cases where we want to either optimise the property of a graph or explore the vicinity of an input graph (prototype) for conditional optimal generations, an approach that has proven successful in controlled image generation (Odena et al., 2016; Chen et al., 2016).
Revised: This becomes very important in cases where we want to either optimise the property of a graph or explore the vicinity of an input graph (prototype) for conditional optimal generations, an approach that has proven successful in controlled image generation (Odena et al., 2016; Chen et al., 2016).

Original: A number of recent approaches (You et al., 2018a; Li et al., 2018a) have tried to overcome this limitation by performing indirect optimisation.
Revised: A number of recent approaches (You et al., 2018a; Li et al., 2018a) have tried to overcome this limitation by performing indirect optimisation.

Original: You et al.
Revised: You et al.

Original: (2018a) include molecular graph optimisation task in a reinforcement learning framework.
Revised: (2018a) include molecular graph optimisation task in a reinforcement learning framework.

Original: However, this method tends to suﬀer from high variance during training.
Revised: However, this method tends to suﬀer from high variance during training.

Original: Kang & Cho (2018) suggest to resort to a reconstruction-based formulation which is directly applicable to discrete structure and does not require gradient estimation.
Revised: Kang & Cho (2018) suggest to resort to a reconstruction-based formulation which is directly applicable to discrete structure and does not require gradient estimation.

Original: However, it is limited by the number of samples available.
Revised: However, it is limited by the number of samples available.

Original: Moreover there is always a risk that the generator simply ignores the part of the latent code containing the property that we want to optimise.
Revised: Moreover there is always a risk that the generator simply ignores the part of the latent code containing the property that we want to optimise.

Original: Finally, Jin et al.
Revised: Finally, Jin et al.

Original: (2018) performs Bayesian optimisation which consists of optimising a proxy (the latent code) of the molecular graph rather than the graph itself.
Revised: (2018) performs Bayesian optimisation which consists of optimising a proxy (the latent code) of the molecular graph rather than the graph itself.

Original: An orthogonal approach is to focus on a graph decoding scheme that outputs the graph all-at-once so that we are able to perform direct optimisation on its probabilistic continuous approximation.
Revised: An orthogonal approach is to focus on a graph decoding scheme that outputs the graph all-at-once so that we are able to perform direct optimisation on its probabilistic continuous approximation.

Original: Simonovsky & Komodakis (2018) and Cao & Kipf (2018) took that direction by having their generator directly output the adjacency and node features tensors of the graph.
Revised: Simonovsky & Komodakis (2018) and Cao & Kipf (2018) took that direction by having their generator directly output the adjacency and node features tensors of the graph.

Original: However, both decoding schemes make use of ﬁxed size MLP layers which restricts their use to very small graphs of a predeﬁned maximum size.
Revised: However, both decoding schemes make use of ﬁxed size MLP layers which restricts their use to very small graphs of a predeﬁned maximum size.

Original: In this work, we address these issues directly by:
Revised: In this work, we address these issues directly by:

Original: • designing a novel diﬀerentiable probabilistic graph decoding scheme that is computationally scalable and is  able to generate arbitrary sized graphs, and • evaluating the generator’s ability to modify molecular graphs attributes in the context of prototype-based molecular graph generation.
Revised: • designing a novel diﬀerentiable probabilistic graph decoding scheme whose number of parameters does not depend on the graph size and is thus able to generate arbitrary sized graphs. • evaluating the generator’s ability to modify molecular graphs attributes in the context of prototype-based molecular graph generation.

Original:  Related work
Revised:  Related work

Original: Lead-based Molecule Optimisation.
Revised: Lead-based Molecule Optimisation.

Original: In the majority of molecule design tasks, the aim is to obtain molecules that optimize certain criteria, for examply activity against a biological target, or physico-chemical properties.
Revised: In the majority of molecule design tasks, the aim is to obtain molecules that optimize certain criteria, for examply activity against a biological target, or physico-chemical properties.

Original: Currently the most popular solution is to ﬁne-tune an existing generative model so that it is likely to produce molecules that satisfy a desired set of properties Segler et al.
Revised: Currently the most popular solution is to ﬁne-tune an existing generative model so that it is likely to produce molecules that satisfy a desired set of properties Segler et al.

Original: However ﬁnding the good training strategy for multiple objectives is challenging for these models.
Revised: However ﬁnding the good training strategy for multiple objectives is challenging for these models.

Original: To that regard, Jin et al.
Revised: To that regard, Jin et al.

Original: (2018) proposed a VAE framework which performs Bayesian optimisation of the molecular graphs in the learned latent space.? and
Revised: (2018) proposed a VAE framework which performs Bayesian optimisation of the molecular graphs in the learned latent space.

Original: Li et al.
Revised: Li et al.

Revised: (2018b) and Li et al.

Original: (2018a) proposed a sequential graph decoding schemes in which conditioning properties can be added as input but here again these methods are unable to perform direct optimisation.
Revised: (2018a) proposed a sequential graph decoding schemes in which conditioning properties can be added as input but here again these methods are unable to perform direct optimisation.

Original: In contrast, You et al.
Revised: In contrast, You et al.

Original: (2018a) recently suggested to perform optimisation while keeping the eﬃcient sequential-like You et al.
Revised: (2018a) recently suggested to perform optimisation while keeping the eﬃcient sequential-like You et al.

Original: (2018b) generative scheme by formulating it as a reinforcement learning problem.
Revised: (2018b) generative scheme by formulating it as a reinforcement learning problem.

Original: Our approach in this paper is to design a scalable  graph decoding scheme that enables us to perform direct optimisation for conditional generation tasks.
Revised: Our approach in this paper is to design a scalable (in the ﬁeld of molecular graphs) graph decoding scheme that enables us to perform direct optimisation for conditional generation tasks.

Original: Graph Generation Models.
Revised: Graph Generation Models.

Original: Current work on graph generation can be divided into two type of graph decoding schemes: the models that generate graphs sequentially You et al.
Revised: Current work on graph generation can be divided into two type of graph decoding schemes: the models that generate graphs sequentially You et al.

Original: (2018b)
Revised: (2018b)

Original: ; Li et al.
Revised: ; Li et al.

Original: (2018a)
Revised: (2018a)

Original: ; You et al.
Revised: ; You et al.

Original: (2018a); ? .
Revised: (2018a) ; Li et al. (2018b).

Original: These methods aim at constructing a graph by predicting a sequence of addition/edition actions.
Revised: These methods aim at constructing a graph by predicting a sequence of addition/edition actions.

Original: The process starts from an empty graph and at each time step a discrete transition is predicted and the graph is updated.
Revised: The process starts from an empty graph and at each time step a discrete transition is predicted and the graph is updated.

Original: While this makes the model scalable as the number of parameters does not depend on the size of the graph, the ﬁnal graph is still non-diﬀerentiable w.r.t.
Revised: While this makes the model scalable as the number of parameters does not depend on the size of the graph, the ﬁnal graph is still non-diﬀerentiable w.r.t.

Original: to the decoder’s parameters which hinders their use for a large range of algorithms to 
Revised: to the decoder’s parameters which hinders their use for a large range of algorithms to perform direct molecular graphs optimisation.

Original: perform direct molecular graphs optimisation. On the other hand, methods in Cao & Kipf (2018); Simonovsky & Komodakis (2018) aim at constructing the graph all-at-once .
Revised: On the other hand, methods in Cao & Kipf (2018); Simonovsky & Komodakis (2018) aim at constructing the graph all-at-once .

Original: These models however make use of ﬁxed size MLP layers to predict the graph adjacency and node tensors which limit their use to graphs of a pre-chosen maximum size and restricts their study to molecular graphs with a maximum number of 9 heavy atoms, compared to ∼ 40 in sequential models.
Revised: These models however make use of ﬁxed size MLP layers to predict the graph adjacency and node tensors which limit their use to graphs of a pre-chosen maximum size and restricts their study to molecular graphs with a maximum number of 9 heavy atoms, compared to ∼ 40 in sequential models.

Original: Moreover, given the graph latent representation z , MLP layers model nodes and edges in the graph conditionally independent.
Revised: Moreover, given the graph latent representation z , MLP layers model nodes and edges in the graph conditionally independent.

Original: This enforces the latent code to contain all the details about the node interdependencies within the graph.
Revised: This enforces the latent code to contain all the details about the node interdependencies within the graph.

Original: Such constraint does not leave space to learn higher level features if the size of the latent code is not chosen carefully.
Revised: Such constraint does not leave space to learn higher level features if the size of the latent code is not chosen carefully.

Original: We propose to tackle these drawbacks by designing a graph decoding scheme that is:
Revised: We propose to tackle these drawbacks by designing a graph decoding scheme that is:

Original: • Scalable : this means that the number of parameters of the decoder should not depend on a ﬁxed pre-deﬁned maximum graph size. • All-at-once : we seek to construct the probabilistic graph all at once to have a diﬀerentiable probabilistic ﬁnal output w.r.t.
Revised: • Scalable : this means that the number of parameters of the decoder should not depend on a ﬁxed pre-deﬁned maximum graph size (compared to Cao & Kipf (2018); Simonovsky & Komodakis (2018) • All-at-once : we seek to construct the probabilistic graph all at once to have a diﬀerentiable probabilistic ﬁnal output w.r.t.

Original: the decoder’s parameters.
Revised: the decoder’s parameters.

Original: This point is particularly important to be able to perform a direct discriminator-based graph optimisation.
Revised: This point is particularly important to be able to perform a direct discriminator-based graph optimisation.

Original: Simple : the autoregressive fashion of modeling continuous node embeddings makes our decoder powerful enough to obtain good reconstruction results on large graphs.
Revised: Simple : the autoregressive fashion of modeling continuous node embeddings makes our decoder powerful enough to obtain good reconstruction results on large molecular graphs .

Original: • Interpretable : the way we construct the adjacency tensor of the graph by learning edge-speciﬁc pairwise similarity metrics allows interpretability for our models. 
Revised: • Interpretable : the way we construct the adjacency tensor of the graph by learning edge-speciﬁc pairwise similarity metrics allows interpretability for our models. Edge-factorization.

Revised: The idea of using tensor factorization methods to decode edges is not new and has been extensively used in relational inference tasks (Nickel & Tresp (2013)).

Revised: Kipf & Welling (2016a) recently proposed an graph autoencoder for rich node embeddings learning and link prediction.

Revised: However their formulation suppose a ﬁxed size graph in which we want to predict existing and potential novel links between its nodes.

Original:   DEFactor
Revised: Such assumption is not applicable to the case of molecular graph optimization where given a property we want to be able to generate a graph of a priori unknown size. To that extent we suggest a novel autoregressive model for nodes embeddings generation which, when combined with edge-factorization graph decoding constitute our full graph decoder. We describe the model more extensively all the modules in the next section.  DEFactor

Original: Molecules can be represented as graphs G =
Revised: Molecules can be represented as graphs G =

Original: ( V, E ) where atoms and bonds correspond to the nodes and edges respectively.
Revised: ( V, E ) where atoms and bonds correspond to the nodes and edges respectively.

Original: Each node in V is labeled with its atom type which can be considered as part of its features.
Revised: Each node in V is labeled with its atom type which can be considered as part of its features.

Original: Equally, a molecular graph can be deﬁned by its adjacency tensor E ∈ { 0 , 1 } n × n × e where n is the number of nodes (atoms) in the graph and e is the number of edge (bond) types that we can have between two atoms and the node types are represented by a node feature tensor N ∈ { 0 , 1 } n × d which is composed of several one-hot-encoded properties.
Revised: Equally, a molecular graph can be deﬁned by its adjacency tensor E ∈ { 0 , 1 } n × n × e where n is the number of nodes (atoms) in the graph and e is the number of edge (bond) types that we can have between two atoms and the node types are represented by a node feature tensor N ∈ { 0 , 1 } n × d which is composed of several one-hot-encoded properties.

Original: In the following sections we will describe our proposed
Revised: In the following sections we will describe our proposed

Original: DEFactor model applied to molecular graphs.
Revised: DEFactor model applied to molecular graphs.

Original: 3. Graph Construction Process
Revised: 3. Graph Construction Process

Original: Given a molecular graph deﬁned as G =
Revised: Given a molecular graph deﬁned as G =

Original: ( N, E ) we propose to leverage the edge-speciﬁc information propagation framework described in Simonovsky & Komodakis (2017) to learn a set of informative embeddings from which we can directly infer a graph.
Revised: ( N, E ) we propose to leverage the edge-speciﬁc information propagation framework described in Simonovsky & Komodakis (2017) to learn a set of informative embeddings from which we can directly infer a graph.

Original: More speciﬁcally, our graph construction process is composed of two parts:
Revised: More speciﬁcally, our graph construction process is composed of two parts:

Original: • An Encoder that in – step 1 performs several spatial graph convolutions on the input graph, and in – step 2 aggregates those embeddings into a single graph latent representation.
Revised: • An Encoder that in – step 1 performs several spatial graph convolutions on the input graph, and in – step 2 aggregates those embeddings into a single graph latent representation.

Original: • A Decoder that in – step 3 autoregressively generates a set of continuous node embeddings conditioned on the learnt latent representation, and in – step 4 reconstruct the whole graph in an edge-factorization fashion.
Revised: • A Decoder that in – step 3 autoregressively generates a set of continuous node embeddings conditioned on the learnt latent representation, and in – step 4 reconstruct the whole graph in an edge-factorization fashion.

Original: Steps 1 and 2: Graph Representation Learning.
Revised: Steps 1 and 2: Graph Representation Learning.

Original: We propose an encoder that makes an eﬃcient use of the information contained in the bonds by having a separate information propagation channel for each bond type.
Revised: We propose an encoder that makes an eﬃcient use of the information contained in the bonds by having a separate information propagation channel for each bond type.

Original: The information is propagated in the graph using a Graph Convolutional Network (GCN) update rule (Kipf & Welling, 2016b) so that each node embedding can be written as a weighted sum of the edge-conditioned information of its neighbors in the graph.
Revised: The information is propagated in the graph using a Graph Convolutional Network (GCN) update rule (Kipf & Welling, 2016b) so that each node embedding can be written as a weighted sum of the edge-conditioned information of its neighbors in the graph.

Original: Namely for each l -th layer of the encoder, the representation is given by:
Revised: Namely for each l -th layer of the encoder, the representation is given by:

Original: [Equation]
Revised: [Equation]

Original: where E e is the e -th frontal slice of the adjacency tensor, D e the corresponding degree tensor and W le and W ls are learned parameters of the layer.
Revised: where E e is the e -th frontal slice of the adjacency tensor, D e the corresponding degree tensor and W le and W ls are learned parameters of the layer.

Original: Once we have those node embeddings we further aggregate them to obtain a ﬁxed-length latent representation of the graph.
Revised: Once we have those node embeddings we further aggregate them to obtain a ﬁxed-length latent representation of the graph.

Original: We propose to parametrize this aggregation step by an
Revised: We propose to parametrize this aggregation step by an

Original: LSTM
Revised: LSTM

Original: and we compute the graph latent representation by a simple linear transformation of the last hidden state of this Aggregator :
Revised: and we compute the graph latent representation by a simple linear transformation of the last hidden state of this Aggregator :

Original: [Equation]
Revised: [Equation]

Original: Even though the use of an LSTM makes the aggregation non permutation-invariant, similar to GraphSAGE Hamilton et al.
Revised: Even though the use of an LSTM makes the aggregation non permutation-invariant, similar to GraphSAGE Hamilton et al.

Original: (2017), we adapt the LSTM aggregator to work on a randomly permuted set of embeddings and noticed that it did not aﬀect the performance of the model.
Revised: (2017), we adapt the LSTM aggregator to work on a randomly permuted set of embeddings and noticed that it did not aﬀect the performance of the model.

Original: In the subsequent steps we are interested in designing a graph decoding scheme from the latent code that is both scalable and powerful enough to model the interdependencies between the nodes and edges in the graph.
Revised: In the subsequent steps we are interested in designing a graph decoding scheme from the latent code that is both scalable and powerful enough to model the interdependencies between the nodes and edges in the graph.

Original: Step 3: Autoregressive Embeddings Generation.
Revised: Step 3: Autoregressive Embeddings Generation.

Original: As speciﬁed above, we are interested in building a graph decoding scheme that models the nodes and their connectivity (represented by continuous embeddings S ) in an autoregressive fashion so that the latent code on which is conditioned the decoding has enough dimensions to encode more highlevel features.
Revised: As speciﬁed above, we are interested in building a graph decoding scheme that models the nodes and their connectivity (represented by continuous embeddings S ) in an autoregressive fashion so that the latent code on which is conditioned the decoding has enough dimensions to encode more highlevel features.

Original: Like stated previously, methods that suggest to compute the graph all at once (Simonovsky & Komodakis, 2018; Cao & Kipf, 2018) model each node and edge as conditionally independent given the latent code z : this means that every detail of their dependencies within the graph has to be encoded in this latent variable: that does not leave much room for high-level feature learning if the size of the latent code is not chosen carefully.
Revised: Like stated previously, methods that suggest to compute the graph all at once (Simonovsky & Komodakis, 2018; Cao & Kipf, 2018) model each node and edge as conditionally independent given the latent code z : this means that every detail of their dependencies within the graph has to be encoded in this latent variable: that does not leave much room for high-level feature learning if the size of the latent code is not chosen carefully.

Original: We propose to tackle this drawback by autoregressive generation of the continuous embeddings s =
Revised: We propose to tackle this drawback by autoregressive generation of the continuous embeddings s =

Original: [ s 0 , s 1 , ..., s n ] for n nodes, with the embedding containing enough information about the node itself and its neighbourhood.
Revised: [ s 0 , s 1 , ..., s n ] for n nodes, with the embedding containing enough information about the node itself and its neighbourhood.

Original: More precisely we model the generation of node embeddings such that:
Revised: More precisely we model the generation of node embeddings such that:

Original: [Equation]
Revised: [Equation]

Original: In our model, the autoregressive generation of embeddings is parametrized by a simple
Revised: In our model, the autoregressive generation of embeddings is parametrized by a simple

Original: LSTM and is completely deterministic such that at each time step t the LSTM decoder takes as input the previously generated embeddings and the latent code z which captured node-invariant features of the graph.
Revised: LSTM and is completely deterministic such that at each time step t the LSTM decoder takes as input the previously generated embeddings and the latent code z which captured node-invariant features of the graph.

Original: Each embedding is computed as a function of the concatenation of the current hidden state and the latent code z such that:
Revised: Each embedding is computed as a function of the concatenation of the current hidden state and the latent code z such that:

Original: [Equation]
Revised: [Equation]

Original: where f dLSTM corresponds to the LSTM recurrence operation and g in and f embed are parametrized as simple MLP layers to perform nonlinear feature extraction.
Revised: where f d LSTM corresponds to the LSTM recurrence operation and g in and f embed are parametrized as simple MLP layers to perform nonlinear feature extraction.

Original: Step 4: Graph Decoding from Node Embeddings.
Revised: Step 4: Graph Decoding from Node Embeddings.

Original: As stated previously, we want to drive the generation of the continuous embeddings s towards latent factors that contains enough information about the node they represent (i.e. we can easily retrieve the one-hot atom type performing a linear transformation of the continuous embedding) and its neighbourhood (i.e. the adjacency tensor can be easily retrieved by comparing those embeddings in a pair-wise manner).
Revised: As stated previously, we want to drive the generation of the continuous embeddings s towards latent factors that contains enough information about the node they represent (i.e. we can easily retrieve the one-hot atom type performing a linear transformation of the continuous embedding) and its neighbourhood (i.e. the adjacency tensor can be easily retrieved by comparing those embeddings in a pair-wise manner).

Original: For those reasons, we suggest to factorize each bond type that we can have between two atoms in a relational inference fashion (Zitnik et al., 2018; Kipf et al., 2018).
Revised: For those reasons, we suggest to factorize each bond type that we can have between two atoms in a relational inference fashion (Zitnik et al., 2018; Kipf et al., 2018).

Original: Let S ∈ R n × p be the concatenated continuous node embeddings generated in the previous step.
Revised: Let S ∈ R n × p be the concatenated continuous node embeddings generated in the previous step.

Original: We reconstruct the adjacency tensor E by learning edge-speciﬁc similarity measure as follows for k -th edge type:
Revised: We reconstruct the adjacency tensor E by learning edge-speciﬁc similarity measure as follows for k -th edge type:

Original: [Equation]
Revised: [Equation]

Original: We model this by a set of edge-speciﬁc factors U= ( u
Revised: We model this by a set of edge-speciﬁc factors U

Original: [Equation] · · · , u e ) ∈
Revised: = ( u 1 , · · · , u e ) ∈

Original: R e × p such that we can reconstruct the adjacency tensor as :
Revised: R e × p such that we can reconstruct the adjacency tensor as :

Original: [Equation]
Revised: [Equation]

Original: where σ is the logistic sigmoid function, D k the corresponding diagonal matrix of the vector u k and the factors ( u i )
Revised: where σ is the logistic sigmoid function, D k the corresponding diagonal matrix of the vector u k and the factors ( u i )

Original: ∈
Revised: ∈

Original: R e × p are learned parameters.
Revised: R e × p are learned parameters.

Original: We reconstruct the node features (i.e. the atom type) with a simple aﬃne transformation such that:
Revised: We reconstruct the node features (i.e. the atom type) with a simple aﬃne transformation such that:

Original: [Equation]
Revised: [Equation]

Original: where W ∈ R p ×
Revised: where W ∈ R p ×

Original: d is a learned parameter.
Revised: d is a learned parameter.

Original: These four steps deﬁne our proposed graph autoencoder.
Revised: These four steps deﬁne our proposed graph autoencoder.

Original: Generating Graphs of Arbitrary Sizes.
Revised: Generating Graphs of Arbitrary Sizes.

Original: In order to generate graphs of diﬀerent sizes we need to add what we call here an Existence module that retrieves a probability of belonging to the ﬁnal graph from each continuous embedding generated by the embeddings generator (in step 3).
Revised: In order to generate graphs of diﬀerent sizes we need to add what we call here an Existence module that retrieves a probability of belonging to the ﬁnal graph from each continuous embedding generated by the embeddings generator (in step 3).

Original: This module is parametrized as a simple MLP layer followed by a sigmoid activation and stops the unrolling of the embedding LSTM generator whenever we encounter a non-informative embedding.
Revised: This module is parametrized as a simple MLP layer followed by a sigmoid activation and stops the unrolling of the embedding LSTM generator whenever we encounter a non-informative embedding.

Original: This module can be interpreted as an < eos > translator.
Revised: This module can be interpreted as an < eos > translator.

Original: 3. Training
Revised: 3. Training

Original: Teacher forcing.
Revised: Teacher forcing.

Original: In order to make the model converge in reasonable time we used a trick similar to the teacher-forcing based training of language models (Williams & Zipser, 1989).
Revised: In order to make the model converge in reasonable time we used a trick similar to the teacher-forcing based training of language models (Williams & Zipser, 1989).

Original: The training is thus done in 3 phases:
Revised: The training is thus done in 3 phases:

Original: • We ﬁrst pre-train the GCN part along with the embedding decoder (factorization, nodes and existence modules) to reconstruct the graphs.
Revised: • We ﬁrst pre-train the GCN part along with the embedding decoder (factorization, nodes and existence modules) to reconstruct the graphs.

Original: This corresponds to the training of a simple Graph AE as in Kipf & Welling (2016a) except that we also want to reconstruct the nodes’ one-hot features (and not just the relations ).
Revised: This corresponds to the training of a simple Graph AE as in Kipf & Welling (2016a) except that we also want to reconstruct the nodes’ one-hot features (and not just the relations ).

Original: • We then append those two units to the embedding aggregator and generator while keeping them ﬁxed.
Revised: • We then append those two units to the embedding aggregator and generator while keeping them ﬁxed.

Original: In this second phase, the embedding generator is trained in a teacher forcing fashion where at each time step t the LSTM decoder does not take as input the previously generated embedding but the true one that is the direct output of the pretrained GCN embedding encoder.
Revised: In this second phase, the embedding generator is trained in a teacher forcing fashion where at each time step t the LSTM decoder does not take as input the previously generated embedding but the true one that is the direct output of the pretrained GCN embedding encoder.

Original: • Finally in order to transition from a teacher-forcing to a fully autoregressive state we increasingly (Bengio et al., 2015) feed the LSTM generator more of its own predictions.
Revised: • Finally in order to transition from a teacher-forcing to a fully autoregressive state we increasingly (Bengio et al., 2015) feed the LSTM generator more of its own predictions.

Original: When that fully autoregressive state is reached the pre-trained units are not frozen anymore and the whole model continues training end-to-end.
Revised: When that fully autoregressive state is reached the pre-trained units are not frozen anymore and the whole model continues training end-to-end.

Original: Log-Likelihood Estimates We train this ﬁrst autoencoder framework in a MLE fashion with the following negative log-likelihood estimate
Revised: Log-Likelihood Estimates We train this ﬁrst autoencoder framework in a MLE fashion with the following negative log-likelihood estimate

Original: L rec =
Revised: L rec =

Original: L X + L ¯ X + L N corresponding to the existing edges ( X ), the non-existing edges ( ¯ X ) and the node features ( N ) reconstruction terms:
Revised: L X + L ¯ X + L N corresponding to the existing edges ( X ), the non-existing edges ( ¯ X ) and the node features ( N ) reconstruction terms:

Original: [Equation]
Revised: [Equation]

Original: where X is the set of existing edges, ¯ X the set of non existing edges, E the adjacency tensor,
Revised: where X is the set of existing edges, ¯ X the set of non existing edges, E the adjacency tensor,

Original: N the node features tensor, n the number of nodes in the graph.
Revised: N the node features tensor, n the number of nodes in the graph.

Original: As molecular graphs are sparse we found that such separate normalisations were crucial for the training.
Revised: As molecular graphs are sparse we found that such separate normalisations were crucial for the training.

Original: 3. Conditional Generation and Optimisation
Revised: 3. Conditional Generation and Optimisation

Original: Model overview.
Revised: Model overview.

Original: In this part we discuss our approach to build a conditional framework starting from the previous autoencoder architecture where the construction of a probabilistic graph ˜ G is conditioned on some unregularized latent code z derived from a given input graph.
Revised: In this part we discuss our approach to build a conditional framework starting from the previous autoencoder architecture where the construction of a probabilistic graph ˜ G is conditioned on some unregularized latent code z derived from a given input graph.

Original: We then augment this unstructured z with a set of structured attributes y that represent some physico-chemical properties of interest so that the decoder is conditioned on the joint ( z, y ).
Revised: We then augment this unstructured z with a set of structured attributes y that represent some physico-chemical properties of interest so that the decoder is conditioned on the joint ( z, y ).

Original: At the end of a successful training we expect this decoder to generate samples that have the properties speciﬁed in y and to be similar (in terms of information contained in z ) to the original query molecular graph (encoded as z ).
Revised: At the end of a successful training we expect this decoder to generate samples that have the properties speciﬁed in y and to be similar (in terms of information contained in z ) to the original query molecular graph (encoded as z ).

Original: To do so we choose a mutual information maximization approach (detailed in the appendix) that involves the use of discriminators that assess the properties ˜
Revised: To do so we choose a mutual information maximization approach (detailed in the appendix) that involves the use of discriminators that assess the properties ˜

Original: y of the generated samples.
Revised: y of the generated samples.

Original: Discriminator Pre-Training
Revised: Discriminator Pre-Training

Original: In this phase we pre-train a discriminator to assess the property y of a generated sample so that we can backpropagate its feedback to the generator (the discriminator can be trained on another dataset and we can have several discriminators for several attributes of interest).
Revised: In this phase we pre-train a discriminator to assess the property y of a generated sample so that we can backpropagate its feedback to the generator (the discriminator can be trained on another dataset and we can have several discriminators for several attributes of interest).

Original: In order to have informative gradients in the early stages of the training we have trained the discriminator on continuous approximations of the discrete training graphs (details in the appendix A.1) so that our objective becomes:
Revised: In order to have informative gradients in the early stages of the training we have trained the discriminator on continuous approximations of the discrete training graphs (details in the appendix A.1) so that our objective becomes:

Original: [Equation]
Revised: [Equation]

Original: where the graphs sampled from ˜ p data ( x ) are the probabilistic approximations of the discrete ones.
Revised: where the graphs sampled from ˜ p data ( x ) are the probabilistic approximations of the discrete ones.

Original: The next step is to incorporate the feedback signal of the trained discriminator in order to formulate the property attribute constraint.
Revised: The next step is to incorporate the feedback signal of the trained discriminator in order to formulate the property attribute constraint.

Original: The training is decomposed in two phases in which we learn to reconstruct graphs of the dataset ( MLE phase) and to modify chemical attributes ( Variational MI maximization phase).
Revised: The training is decomposed in two phases in which we learn to reconstruct graphs of the dataset ( MLE phase) and to modify chemical attributes ( Variational MI maximization phase).

Original: Encoder Learning.
Revised: Encoder Learning.

Original: The encoder is updated only during the reconstruction phase where we sample attributes y from the true posterior.
Revised: The encoder is updated only during the reconstruction phase where we sample attributes y from the true posterior.

Original: The encoder loss is a linear combination of the molecular graph reconstruction ( L rec ) and the property reconstruction( L prop ) s.t.
Revised: The encoder loss is a linear combination of the molecular graph reconstruction ( L rec ) and the property reconstruction( L prop ) s.t.

Original: L rec =
Revised: L rec =

Original: E ( x,y ) ∼ p data ( x,y ) ,z ∼ E ( z | x ) [ − log p gen ( x | z, y )]
Revised: E ( x,y ) ∼ p data ( x,y ) ,z ∼ E ( z | x ) [ − log p gen ( x | z, y )]

Original: (using the log-likelihood estimates in (7) ) and L prop = E ( x,y ) ∼ p data ( x,y ) ,z ∼ E ( z | x ) ,x 0 ∼ p
Revised: (using the log-likelihood estimates in (7) ) and L prop = E ( x,y ) ∼ p data ( x,y ) ,z ∼ E ( z | x ) ,x 0 ∼ p

Original: gen
Revised: gen

Original: ( x | z,y ) [ − log Q
Revised: ( x | z,y ) [ − log Q

Original: ( y | x 0 )].
Revised: ( y | x 0 )].

Original: The total encoder loss is:
Revised: The total encoder loss is:

Original: [Equation]
Revised: [Equation]

Original: [Equation]

Original: Generator Learning.
Revised: Generator Learning.

Original: The generator is updated in both reconstruction and conditional phases.
Revised: The generator is updated in both reconstruction and conditional phases.

Original: In the MLE phase the generator is trained with same loss L enc as the encoder so that it is pushed towards generating realistic molecular graphs.
Revised: In the MLE phase the generator is trained with same loss L enc as the encoder so that it is pushed towards generating realistic molecular graphs.

Original: In the MI maximization  phase we sample the attributes from a prior p ( y ) s.t.
Revised: In the MI maximization [Table] phase we sample the attributes from a prior p ( y ) s.t.

Original: we minimize the following objective:
Revised: we minimize the following objective:

Original: [Equation]
Revised: [Equation]

Original: In this phase the only optimisation signal comes from the trained discriminator.
Revised: In this phase the only optimisation signal comes from the trained discriminator.

Original: Consequently there is a risk of falling oﬀ the manifold of the molecular graphs as no realism constraint is speciﬁed.
Revised: Consequently there is a risk of falling oﬀ the manifold of the molecular graphs as no realism constraint is speciﬁed.

Original: A good way to make sure that this does not happen is to add a similar discriminator trained to distinguish between the real probabilistic graph and the generated ones so that when trying to satisfy the attribute constraint the generator is forced to produce valid molecular graphs.
Revised: A good way to make sure that this does not happen is to add a similar discriminator trained to distinguish between the real probabilistic graph and the generated ones so that when trying to satisfy the attribute constraint the generator is forced to produce valid molecular graphs.

Original: We leave that additional feature for future work.
Revised: We leave that additional feature for future work.

Original:  Experiments 4. Dataset
Revised:  Experiments 4. Dataset

Original: Training is performed on a subset of the ZINC Irwin et al.
Revised: Training is performed on a subset of the ZINC Irwin et al.

Original: (2012) dataset, keeping the molecules with less than 33 heavy atoms ( ∼ 200k examples).[Table]
Revised: (2012) dataset, keeping the molecules with less than 33 heavy atoms ( ∼ 200k examples).

Original: 4. Results
Revised: 4. Results

Original: Reconstruction.
Revised: Reconstruction.

Original: We evaluate the ability of our probabilistic factorization-based model to generate a graph through the full autoencoder framework.
Revised: We evaluate the ability of our probabilistic factorization-based model to generate a graph through the full autoencoder framework.

Original: We want to check whether given a molecular graph we are able to encode it and decode it back with a multi-relational tensor factorization approach, correctly reconstructing it.
Revised: We want to check whether given a molecular graph we are able to encode it and decode it back with a multi-relational tensor factorization approach, correctly reconstructing it.

Original: We report here the ratio of exact reconstructions for the full graph autoencoder on the ZINC test set compared to other graph generation methods.
Revised: We report here the ratio of exact reconstructions for the full graph autoencoder on the ZINC test set compared to other graph generation methods.

Original: Our results are reported in Table 1.
Revised: Our results are reported in Table 1.

Original: It shows that DEFactor outperforms previous models in terms of molecular graph reconstruction with fewer parameters and no validity check added during training.
Revised: It shows that DEFactor outperforms previous models in terms of molecular graph reconstruction with fewer parameters and no validity check added during training.

Original: We believe that is explainable by a powerful decoder that models the interdependencies between the nodes in the graph through the autoregressive generation of continuous embeddings, thus the size of the latent space does not seem to have much eﬀect on the results (we report the reconstruction results as a function of the number of heavy atoms in the molecule in the appendix).
Revised: We believe that is explainable by a powerful decoder that models the interdependencies between the nodes in the graph through the autoregressive generation of continuous embeddings, thus the size of the latent space does not seem to have much eﬀect on the results (we report the reconstruction results as a function of the number of heavy atoms in the molecule in the appendix).

Original: LogP Optimisation and Conditional Generation.
Revised: LogP Optimisation and Conditional Generation.

Original: In this section, we evaluate the ability of the decoder to control its output attributes in the context of conditional LogP optimisation.
Revised: In this section, we evaluate the ability of the decoder to control its output attributes in the context of conditional LogP optimisation.

Original: First we directly evaluate the optimisation ability in the conditional context by plotting the target property (i.e. input of the decoder) as a function of the real attribute  of the output for molecules in the test set.
Revised: First we directly evaluate the optimisation ability in the conditional context by plotting the target property (i.e. input of the decoder) as a function of the real attribute [Table] of the output for molecules in the test set.

Original: The results are shown in Fig.
Revised: The results are shown in Fig.

Original: 2, where we see that in a majority of cases the model is able to generate a molecule with the desired conditioning property using the input molecule as a prototype.
Revised: 2, where we see that in a majority of cases the model is able to generate a molecule with the desired conditioning property using the input molecule as a prototype.

Original: More visual examples of the prototype and generated molecules with increasing LogP can be seen in the Appendix. 
Revised: More visual examples of the prototype and generated molecules with increasing LogP can be seen in the Appendix. graph when translated back into molecule (we have of course only reported the values when the decoded graphs correspond to valid molecules, which explains the diﬀerence in the total number of points for each query molecule).

Original: For the second experiment, we quantify the the ability of the model to increase LogP in an implicit constrained scenario for a set of molecules in the test set.
Revised: For the second experiment, we quantify the the ability of the model to increase LogP in an implicit constrained scenario for a set of molecules in the test set.

Original: Similar to You et al.
Revised: Similar to You et al.

Original: (2018a); Jin et al.
Revised: (2018a); Jin et al.

Original: we took the 800 molecules with lowest penalized LogP (as deﬁned in
Revised: we took the 800 molecules with lowest penalized LogP (as deﬁned in

Original: GÃşmez-Bombarelli et al.
Revised: GÃşmez-Bombarelli et al.

Original: (2016)) score.
Revised: (2016)) score.

Original: However, instead of training the model to condition on the penalized LogP we trained it to condition on the LogP score only and evaluated the improvements made in terms of penalized LogP. We are interested to know if the model learns by itself to target the given LogP while producing synthetically accessible molecules.
Revised: However, instead of training the model to condition on the penalized LogP we trained it to condition on the LogP score only and evaluated the improvements made in terms of penalized LogP. We are interested to know if the model learns by itself to target the given LogP while producing synthetically accessible molecules.

Original: In Table 2, we report the success rate for how often a modiﬁcation succeeds (Suc.) and among those the average improvement (Imp.) and molecular similarity (Sim.) between the original molecules and the highest improvement for diﬀerent thresholds δ on the similarity constraint (measured based on the Tanimoto distance).
Revised: In Table 2, we report the success rate for how often a modiﬁcation succeeds (Suc.) and among those the average improvement (Imp.) and molecular similarity (Sim.) between the original molecules and the highest improvement for diﬀerent thresholds δ on the similarity constraint (measured based on the Tanimoto distance).

Original: As can be seen, DEFactor while being slightly behind GCPN w.r.t.
Revised: As can be seen, DEFactor while being slightly behind GCPN w.r.t.

Original: success rates, signiﬁcantly outperforms other models in terms of improvements achieved (between 130 × and 195 × better optimised molecules compared to GCPN, the next best model).
Revised: success rates, signiﬁcantly outperforms other models in terms of improvements achieved (between 130 × and 195 × better optimised molecules compared to GCPN, the next best model).

Original: We believe the main reason for lower success rate for DEFactor is that we do not formulate any explicit validity/realism constraint in the training process.[Table]
Revised: We believe the main reason for lower success rate for DEFactor is that we do not formulate any explicit validity/realism constraint in the training process.

Original:  Future work
Revised:  Future work

Original: In this paper [Table] we designed a new way of modelling graphs and generating new ones in a conditional optimisation setup s.t.
Revised: In this paper, we designed a new way of modelling graphs and generating new ones in a conditional optimisation setup s.t.

Original: the ﬁnal graph being fully diﬀerentiable w.r.t to the model parameters.
Revised: the ﬁnal graph being fully diﬀerentiable w.r.t to the model parameters.

Original: We believe that our DEFactor model is a signiﬁcant step forward to build ML-driven applications for de-novo drug design or generation of molecules with optimal properties without resorting to methods that do not directly optimise the desired properties.
Revised: We believe that our DEFactor model is a signiﬁcant step forward to build ML-driven applications for de-novo drug design or generation of molecules with optimal properties without resorting to methods that do not directly optimise the desired properties.

Original: Note that a drawback of our model is that it uses an MLE training process which forces us to either ﬁx the ordering of nodes or to perform a computationally expensive graph matching operation to compute the loss.
Revised: Note that a drawback of our model is that it uses an MLE training process which forces us to either ﬁx the ordering of nodes or to perform a computationally expensive graph matching operation to compute the loss.

Original: Moreover in our fully deterministic conditional formulation we assume that chemical properties optimisation is a one-to-one mapping but in reality there may exist many suitable way of optimizing a molecule to satisfy one property condition while staying similar to the query molecule.
Revised: Moreover in our fully deterministic conditional formulation we assume that chemical properties optimisation is a one-to-one mapping but in reality there may exist many suitable way of optimizing a molecule to satisfy one property condition while staying similar to the query molecule.

Original: To that extent it could be interesting to augment our model to include the possibility of a one-to-many mapping.
Revised: To that extent it could be interesting to augment our model to include the possibility of a one-to-many mapping.

Original: Another way of improving the model could also be to include a validity constraint formulated as training a discriminator that discriminates between valid and generated graphs.
Revised: Another way of improving the model could also be to include a validity constraint formulated as training a discriminator that discriminates between valid and generated graphs.

Original: Appendix A Conditionnal setting A. Graphs continuous approximation
Revised: Appendix A Conditionnal setting A. Graphs continuous approximation

Original: For the pre-training of the discriminators we suggested to train them on continuous approximation of the discrete graphs that ressembles the output of the decoder.
Revised: For the pre-training of the discriminators we suggested to train them on continuous approximation of the discrete graphs that ressembles the output of the decoder.

Original: To that extent we used the trained partial graph autoencoder (used for the teacher forcing at the beginning of the training of the full autoencoder)
Revised: To that extent we used the trained partial graph autoencoder (used for the teacher forcing at the beginning of the training of the full autoencoder)

Original: A. Mutual information maximization
Revised: A. Mutual information maximization

Original: For the conditional setting we choose a simple mutual information maximization formulation.
Revised: For the conditional setting we choose a simple mutual information maximization formulation.

Original: The objective is to maximize the MI
Revised: The objective is to maximize the MI

Original: I ( X ; Y ) between the target property Y and the decoder’s output X =
Revised: I ( X ; Y ) between the target property Y and the decoder’s output X =

Original: G θ ( Y ) under the joint p θ ( X, Y ) deﬁned by the decoder
Revised: G θ ( Y ) under the joint p θ ( X, Y ) deﬁned by the decoder

Original: G θ .
Revised: G θ .

Original: In the conditional setting G θ is also conditioned on the encoded molecule z but for simplicity we treat it as a parameter of the decoder (and thus reason with one target molecule from which we want to modify attributes).
Revised: In the conditional setting G θ is also conditioned on the encoded molecule z but for simplicity we treat it as a parameter of the decoder (and thus reason with one target molecule from which we want to modify attributes).

Original: We deﬁne the MI as:
Revised: We deﬁne the MI as:

Original: [Equation]
Revised: [Equation]

Original: In our conditional setting we pre-trained the discriminators (parametrized by Q in the lower bound derivation) to approximate p data ( y | x ) which makes the bound tight only when p θ ( y paired | x ) is close to p data ( y | x ) and this corresponds to a stage where the decoder has maximized the log-likelihood of the data well enough (i.e. when it is able to reconstruct input graphs properly when z and y are paired).
Revised: In our conditional setting we pre-trained the discriminators (parametrized by Q in the lower bound derivation) to approximate p data ( y | x ) which makes the bound tight only when p θ ( y paired | x ) is close to p data ( y | x ) and this corresponds to a stage where the decoder has maximized the log-likelihood of the data well enough (i.e. when it is able to reconstruct input graphs properly when z and y are paired).

Original: Thus, in the conditional setting we are maximizing the following objective:
Revised: Thus, in the conditional setting we are maximizing the following objective:

Original: [Figure]
Revised: [Equation]

Original: A. Reconstruction as a function of number of atoms
Revised: A. Reconstruction as a function of number of atoms

Original: Notice that as we make use of a simple LSTM to encode a graph representation, there is a risk that for the largest molecules the long term dependencies of the embeddings are not captured well resulting in a bad reconstruction error.
Revised: Notice that as we make use of a simple LSTM to encode a graph representation, there is a risk that for the largest molecules the long term dependencies of the embeddings are not captured well resulting in a bad reconstruction error.

Original: We capture this observation in ﬁgure 4.
Revised: We capture this observation in ﬁgure 4.

Original: One possible amelioration could be to add other at each step other non-sequential aggregation of the embeddings (average pooling of the emebeddings for example) or to make the encoder more powerful by adding some attention mechanisms.
Revised: One possible amelioration could be to add other at each step other non-sequential aggregation of the embeddings (average pooling of the emebeddings for example) or to make the encoder more powerful by adding some attention mechanisms.

Original: We leave those for future work.
Revised: We leave those for future work.

Original: A. Visual similarity samples
Revised: A. Visual similarity samples

Original: [Figure]