S YNTAX -D
IRECTED
V
ARIATIONAL A UTOENCODER
FOR S TRUCTURED D ATA
Anonymous authors
Paper under double-blind review
A
BSTRACT
Deep generative models have been enjoying success in modeling continuous data.
However it remains challenging to capture the representations for discrete structures with formal grammars and semantics, e.g. , computer programs and molecular structures.
How to generate both syntactically and semantically correct data still remains largely an open problem.
Inspired by the theory of compiler where the syntax and semantics check is done via syntax-directed translation (SDT), we propose a novel syntax-directed variational autoencoder (SD-VAE) by introducing stochastic lazy attributes .
This approach converts the ofﬂine SDT check into on-the-ﬂy generated guidance for constraining the decoder.
Comparing to the state-of-the-art methods, our approach enforces constraints on the output space so that the output will be not only syntactically valid, but also semantically reasonable.
We evaluate the proposed model with applications in programming language and molecules, including reconstruction and program/molecule optimization.
The results demonstrate the effectiveness in incorporating syntactic and semantic constraints in discrete generative models, which is signiﬁcantly better than current state-of-the-art approaches.
I NTRODUCTION
Recent advances in deep representation learning have resulted in powerful probabilistic generative models which have demonstrated their ability on modeling continuous data, e.g. , time series signals (Oord et al., 2016; Dai et al., 2017) and images (Radford et al., 2015; Karras et al., 2017).
Despite the success in these domains, it is still challenging to correctly generate discrete structured data, such as graphs, molecules and computer programs.
Since many of the structures have syntax and semantic formalisms, the generative models without explicit constraints often produces invalid ones.
Conceptually an approach in generative model for structured data can be divided in two parts, one being the formalization of the structure generation and the other one being a (usually deep) generative model producing parameters for stochastic process in that formalization.
Often the hope is that with the help of training samples and capacity of deep models, the loss function will prefer the valid patterns and encourage the mass of the distribution of the generative model towards the desired region automatically.
Arguably the simplest structured data are sequences, whose generation with deep model has been well studied under the seq2seq (Sutskever et al., 2014) framework that models the generation of sequence as a series of token choices parameterized by recurrent neural networks (RNNs).
Its widespread success has encourage several pioneer works that consider the conversion of more complex structure data into sequences and apply sequence models to the represented sequences.
G ´ omez-Bombarelli et al.
(2016) (CVAE) is a representative work of such paradigm for the chemical molecule generation, using the SMILES line notation (Weininger, 1988) for representing molecules.
However, because of the lack of formalization of syntax and semantics serving as the restriction of the particular structured data, underﬁtted general-purpose string generative models will often lead to invalid outputs.
Therefore, to obtain a reasonable model via such training procedure, we need to prepare large amount of valid combinations of the structures, which is time consuming or even not practical in domains like drug discovery.
[Figure]
To tackle such a challenge, one approach is to incorporate the structure restrictions explicitly into the generative model.
For the considerations of computational cost and model generality, contextfree grammars (CFG) have been taken into account in the decoder parametrization.
For instance, in molecule generation tasks, Kusner et al.
(2017) proposes a grammar variational autoencoder (GVAE) in which the CFG of SMILES notation is incorporated into the decoder.
The model generates the parse trees directly in a top-down direction, by repeatedly expanding any nonterminal with its production rules.
Although the CFG provides a mechanism for generating syntactic valid objects, it is still incapable to regularize the model for generating semantic valid objects (Kusner et al., 2017).
For example, in molecule generation, the semantic of the SMILES languages requires that the rings generated must be closed; in program generation, the referenced variable should be deﬁned in advance and each variable can only be deﬁned exactly once in each local context (illustrated in Fig 1b).
All the examples require cross-serial like dependencies which are not enforceable by CFG, implying that more constraints beyond CFG are needed to achieve semantic valid production in VAE.
In the theory of compiler, attribute grammars, or syntax-directed deﬁnition has been proposed for attaching semantics to a parse tree generated by context-free grammar.
Thus one straightforward but not practical application of attribute grammars is, after generating a syntactic valid molecule candidate, to conduct ofﬂine semantic checking.
This process needs to be repeated until a semantically valid one is discovered, which is at best computationally inefﬁcient and at worst infeasible, due to extremely low rate of passing checking.
As a remedy, we propose the syntax-direct variational autoencoder (SD-VAE), in which a semantic restriction component is advanced to the stage of syntax tree generator.
This allows the generator with both syntactic and semantic validation.
The proposed syntax-direct generative mechanism in the decoder further constraints the output space to ensure the semantic correctness in the tree generation process.
The relationships between our proposed model and previous models can be characterized in Figure 1a.
Our method brings theory of formal language into stochastic generative model.
The contribution of our paper can be summarized as follows:
• Syntax and semantics enforcement : We propose a new formalization of semantics that systematically converts the ofﬂine semantic check into online guidance for stochastic generation using the proposed stochastic lazy attribute .
This allows
us effectively
address both syntax and semantic constraints.
• Efﬁcient learning and inference: Our approach has computational cost O ( n ) where n is the length of structured data.
This is the same as existing methods like CVAE and GVAE which do not enforce semantics in generation.
During inference, the SD-VAE runs with semantic guiding onthe-ﬂy, while the existing alternatives generate many candidates for semantic checking.
• Strong empirical performance : We demonstrate the effectiveness of the SD-VAE through applications in two domains, namely (1) the subset of Python programs and (2) molecules.
Our approach consistently and signiﬁcantly improves the results in evaluations including generation,
reconstruction and optimization.
B ACKGROUND
Before introducing our model and the learning algorithm, we ﬁrst provide some background knowledge which is important for understanding the proposed method.
2. V ARIATIONAL A UTOENCODER
The variational autoencoder (Kingma & Welling, 2013; Rezende et al., 2014) provides a framework for learning the probabilistic generative model as well as its posterior, respectively known as decoder and encoder.
We denote the observation as x , which is the structured data in our case, and the latent variable as z .
The decoder is modeling the probabilistic generative processes of x given the continuous representation z through the likelihood p θ ( x | z ) and the prior over the latent variables p ( z ) , where θ denotes the parameters.
The encoder approximates the posterior p θ ( z | x ) ∝ p θ ( x | z ) p ( z ) with a model q ψ ( z | x ) parametrized by ψ .
The decoder and encoder are learned simultaneously by maximizing the evidence lower bound (ELBO) of the marginal likelihood, i.e. ,
L ( X ; θ, ψ ) :
= (cid:88)
[Equation]
where X denotes the training datasets containing the observations.
2. C ONTEXT F REE G RAMMAR AND A TTRIBUTE G RAMMAR Context free grammar
A context free grammar (CFG) is deﬁned as G =
(cid:104)V , Σ , R , s (cid:105) , where symbols are divided into V , the set of non-terminal symbols, Σ , the set of terminal symbols and s ∈ V , the start symbol.
Here R is the set of production rules.
Each production rule r ∈ R is denoted as r = α → β for α ∈ V is a nonterminal symbol, and
β = u 1 u 2 . . .
u | β | ∈ ( V (cid:83) Σ) ∗ is a sequence of terminal and/or nonterminal symbols.
Attribute grammar To enrich the CFG with “semantic meaning”, Knuth (1968) formalizes attribute grammar that introduces attributes and rules to CFG.
An attribute is an attachment to the corresponding nonterminal symbol in CFG, written in the format (cid:104) v (cid:105) .
a for v ∈ V .
There can be two types of attributes assigned to non-terminals in G : the inherited attributes and the synthesized attributes.
An inherited attribute depends on the attributes from its parent and siblings, while a synthesized attribute is computed based on the attributes of its children.
Formally, for a production u 0 → u 1 u 2 . . .
u | β | , we denote I ( u i ) and S ( u i ) be the sets of inherited and synthesized attributes of u i for i ∈ { 0 , . . .
, | β |} , respectively.
2.2. A MOTIVATIONAL EXAMPLE
We here exemplify how the above deﬁned attribute grammar enriches CFG with non-context-free semantics.
We use the following toy grammar, a subset of SMILES that generates either a chain or a cycle with three carbons:
Production
[Table]
[Equation]
[Table] [Table]
[Table] [Table]
[Table]
where we show the production rules in CFG with → on the left, and the calculation of attributes in attribute grammar with ← on the left.
Here we leverage the attribute grammar to check (with attribute matched ) whether the ringbonds come in pairs: a ringbond generated at (cid:104) atom (cid:105) 1 should match the bond type and bond index that generated at (cid:104) atom (cid:105) 2 , also the semantic constraint expressed by (cid:104) s (cid:105) .ok
requires that there is no difference between the set attribute of (cid:104) atom (cid:105) 1 and (cid:104) atom (cid:105) 2 .
Such constraint in SMILES is known as cross-serial dependencies (CSD) (Bresnan et al., 1982) which is non-context-free (Shieber, 1985).
See Appendix A.3 for more explanations.
Figureillustrates the process of performing syntax and semantics check in compilers.
Here all the attributes are synthetic , i.e. , calculated in a bottom-up direction.
<atom><atom> 2 ‘C’ <digit> <bond> ‘C’ ‘C’ <bond> <digit> ‘-’ ‘1’ ‘-’ ‘1’
[Figure]
Non
[Figure]
Attribute Synthesize dependency
CFG Parsing for syntax <digit> 
 <atom><atom> 2 ‘C’ <digit> <bond> ‘C’ ‘C’ <bond> ‘-’ ‘1’ ‘-’ ‘1’
C-1CCSyntax Check
Semantics Check matched={‘-1’} ∩ {‘-1’} ok=True set={‘-1’} val=‘-’ val=‘1’ val=‘1’ val=‘-’ set={‘-1’}
[Figure]
So generally, in the semantic correctness checking procedure, one need to perform bottom-up procedures for calculating the attributes after the parse tree is generated.
However, in the top-down structure generating process, the parse tree is not ready for semantic checking, since the synthesized attributes of each node require information from its children nodes, which are not generated yet.
Due to such dilemma, it is nontrivial to use the attribute grammar to guide the top-down generation of the tree-structured data.
One straightforward way is using acceptance-rejection sampling scheme, i.e. , using the decoder of CVAE or GVAE as a proposal and the semantic checking as the threshold.
It is obvious that since the decoder does not include semantic guidance, the proposal distribution may raise semantically invalid candidate frequently, therefore, wasting the computational cost in vain.
S YNTAX -D IRECTED V ARIATIONAL A UTOENCODER
As described in Section 2.2.1, directly using attribute grammar in an ofﬂine fashion ( i.e. , after the generation process ﬁnishes) is not efﬁcient to address both syntax and semantics constraints.
In this section we describe how to bring forward the attribute grammar online and incorporate it into
VAE, such that our VAE addresses both syntactic and semantic constraints.
We name our proposed method Syntax-Directed Variational Autoencoder (SD-VAE).
3. S TOCHASTIC S YNTAX -D IRECTED D ECODER
By scrutinizing the tree generation, the major difﬁculty in incorporating the attributes grammar into the processes is the appearance of the synthesized attributes.
For instance, when expanding the start symbol (cid:104) s (cid:105) , none of its children is generated yet.
Thus their attributes are also absent at this time, making the (cid:104) s (cid:105) .
matched unable to be computed.
To enable the on-the-ﬂy computation of the synthesized attributes for semantic validation during tree generation, besides the two types of attributes, we introduce the stochastic lazy attributes to enlarge the existing attribute grammar.
Such stochasticity transforms the corresponding synthesized attribute into inherited constraints in generative procedure; and lazy linking mechanism sets the actual value of the attribute, once all the other dependent attributes are ready.
We demonstrate how the decoder with stochastic lazy attributes will generate semantic valid output through the same pedagogical example as in Section 2.2.1.
Figurevisually demonstrates this process.
The tree generation procedure is indeed sampling from the decoder p θ ( x | z ) , which can be decomposed into several steps that elaborated below:
i) stochastic predetermination: in Figure 3(a), we start from the node (cid:104)
s
(cid:105)
with the synthe
- sized attributes (cid:104) s (cid:105) .
matched
determining
the index and
bond
type of the ringbond that will
be
matched at node (cid:104) s (cid:105) .
Since we know nothing about the children nodes right now, the only thing we can do is to ‘guess’ a value.
That is to say, we associate a stochastic attribute (cid:104) s (cid:105) .
sa ∈ { 0 , 1 } C a ∼ (cid:81) C
a i =1 B ( sa i | z ) as a predetermination for the sake of the absence of synthesized attribute
(cid:104)
s (cid:105) .
matched , where B ( · ) is the Bernoulli distribution.
Here C a is the maximum cardinality
<atom><atom> 2 ‘C’ ~ 𝑝 " (𝑟| 
 ,𝒯 (() ) sa ~ ℬ " (𝑠𝑎| 
 ,𝒯 (() ) 1<atom> 2 ‘C’ sa= <digit> <bond> ‘C’ ‘C’ 𝑝 " (𝑟| <atom> 1, 𝒯 (.) )
X <atom> 2 ‘C’ sa=1 <atom>
 sa= ‘C’ <atom>sa=1 ~ 𝑝 " (𝑟| <bond> , 𝒯 (/) )
~ ‘-’ ‘=’ ‘#’ …… ‘1’ ‘9’ …… 𝑝 " (𝑟| <digit> , 𝒯 (0) )
~ <digit> <bond> <digit> <bond> ‘C’ ‘-’ ‘1’ <atom><atom> 2 ‘C’ sa=1 
 sa= val=‘1’ val=‘-’ set={‘-1’} <digit> <bond> ‘C’ ‘-’ ‘1’ <atom><atom> 2 ‘C’ sa=1 
 sa= val=‘1’ val=‘-’ set={‘-1’} matched ={‘ -1 ’} <digit> <bond> ‘C’ ‘-’ ‘1’ <
atom>‘C’ sa=1 
 sa= val=‘1’ val=‘-’ set={‘-1’} matched ={‘ -1 ’} <digit> <bond> ‘C’ ‘C’ <atom>matched={‘-1’} ~
𝑝 " (𝑟| <atom> 2, 𝒯 (2) )
X <digit> <bond> ‘C’ ‘-’ ‘1’ <atom>‘C’ sa=1 
 sa= val=‘1’ val=‘-’ set={‘-1’} matched ={‘ -1 ’} <atom> 2 matched={‘-1’} ‘C’ ‘-’ ‘=’ ‘#’ xxxxxx ‘1’ ‘9’ ……
X X
X <digit> <bond> ~ 𝑝 " (𝑟| <bond> , 𝒯 (3) ) 𝑝 " (𝑟| <digit> , 𝒯 (4) ) matched={‘-1’}
ProbabilitySimplex
Sampling InheritedAttribute StochasticLazy Attribute
Generated Partial Tree Banned option ~
X 𝒯 (5) (
[Figure]
) (b) (c) (d)
[Figure]
Algorithm
1: Global variables: CFG: G =
( V , Σ , R , s ) , decoder network parameters θ 2: procedure G EN T REE ( node , T ) 3:
Sample stochastic lazy attribute node.
sa ∼ B θ ( sa | node, T ) (cid:46) when introduced on node 4:
Sample production rule r = ( α → β ) ∈
R ∼ p θ ( r | ctx, node, T ) .
(cid:46)
The conditioned variables encodes the semantic constraints in tree generation.
5: ctx ← RNN ( ctx, r ) (cid:46) update context vector 6: for i = 1 , . .
. , | β | do 7: v i ← Node ( u i , node, { v j } i − 1 j =1 ) (cid:46) node creation with parent and siblings’ attributes 8:
GenTree( v i , T ) (cid:46) recursive generation of children nodes 9:
Update synthetic and stochastic attributes of node with v i (cid:46)
Lazy linking 10: end for 11: end procedure possible 1 for the corresponding attribute a .
In above example, the 0 indicates no ringbond andindicates one ringbond at both (cid:104) atom (cid:105) 1 and (cid:104) atom (cid:105) 2 , respectively.
ii) constraints as inherited attributes: we pass the (cid:104) s (cid:105) .
sa as inherited constraints to the children of node (cid:104) s (cid:105) , i.e. , (cid:104) atom (cid:105) 1 and (cid:104) atom (cid:105) 2 to ensure the semantic validation in the tree generation.
For example, Figure 3(b) ‘sa=1’ is passed down to (cid:104) atom (cid:105) 1 . iii) sampling under constraints: without loss of generality, we assume (cid:104) atom (cid:105) 1 is generated before (cid:104) atom (cid:105) 2 .
We then sample the rules from p θ ( r |(cid:104) atom (cid:105) 1 , (cid:104) s (cid:105) , z ) for expanding (cid:104) atom (cid:105) 1 , and so on and so forth to generate the subtree recursively.
Since we carefully designed sampling distribution that is conditioning on the stochastic property, the inherited constraints will be eventually satisﬁed.
In the example, due to the (cid:104) s (cid:105) .
sa = ‘1’ , when expanding (cid:104) atom (cid:105) 1 , the sampling distribution p θ ( r |(cid:104) atom (cid:105) 1 , (cid:104) s (cid:105) , z ) only has positive mass on rule (cid:104) atom (cid:105) → ‘C’ (cid:104) bond (cid:105) (cid:104) digit (cid:105) .
iv) lazy linking: once we complete the generation of the subtree rooted at (cid:104) atom (cid:105) 1 , the synthesized attribute (cid:104) atom (cid:105) 1 .
set is now available.
According to the semantic rule for (cid:104) s (cid:105) .
matched , we can instantiate (cid:104) s (cid:105) .
matched =
(cid:104) atom (cid:105) 1 .
set = { ‘-1’ } .
This linking is shown in Figure 3(d)(e).
When expanding (cid:104) atom (cid:105) 2 , the (cid:104) s (cid:105) .
matched will be passed down as inherited attribute to regulate the generation of (cid:104) atom (cid:105) 2 , as is demonstrated in Figure 3(f)(g).
In summary, the general syntax tree T ∈ L ( G ) can be constructed step by step, within the languages
L ( G ) covered by grammar G .
In the beginning, T (0) = root ,
where root.
symbol =
s which contains only the start symbol s .
At step t , we will choose an nonterminal node in the frontier 2 of partially generated tree T ( t ) to expand.
The generative process in each step t = 0 , 1 , . . .
can be described as:
Pick node v ( t ) ∈
Fr ( T ( t ) ) where its attributes needed are either satisﬁed, or are stochastic attributes that should be sampled ﬁrst according to Bernoulli distribution B ( ·| v ( t ) , T ( t ) ) ; 2.
Sample rule r ( t ) =
α ( t ) → β ( t ) ∈ R according to distribution p θ ( r ( t ) | v ( t ) , T ( t ) ) , where v ( t ) .
symbol =
α ( t ) , and β ( t ) =
u ( t ) 1 u ( t ) 2 . . .
u ( t ) | β ( t ) | , i.e. , expand the nonterminal with production rules deﬁned in CFG.
T ( t +1)
=
T ( t ) (cid:83) { ( v ( t ) , u ( t ) i ) } | β ( t ) | i =1 , i.e. , grow the tree by attaching β ( t ) to v ( t ) .
Now the node v ( t ) has children represented by symbols in β ( t ) .
The above process continues until all the nodes in the frontier of T ( T ) are all terminals after T steps.
Then, we obtain the algorithm 1 for sampling both syntactic and semantic valid structures.
In fact, in the model training phase, we need to compute the likelihood p θ ( x | z ) given x and z .
The probability computation procedure is similar to the sampling procedure in the sense that both of them requires tree generation.
The only difference is that in the likelihood computation procedure, the tree structure, i.e. , the computing path, is ﬁxed since x is given; While in the sampling procedure, it is sampled following the learned model.
Speciﬁcally, the generative likelihood can be written as:
[Equation]
) where ctx (0)
=
z and ctx ( t ) =
RNN ( r t , ctx ( t − 1) ) .
Here RNN can be commonly used LSTM, etc. .
3. S TRUCTURE -B ASED E NCODER
As we introduced in section 2, the encoder, q ψ ( z | x ) approximates the posterior of the latent variable through the model with some parametrized function with parameters ψ .
Since the structure in the observation x plays an important role, the encoder parametrization should take care of such information.
The recently developed deep learning models (Duvenaud et al., 2015; Dai et al., 2016; Lei et al., 2017) provide powerful candidates as encoder.
However, to demonstrate the beneﬁts of the proposed syntax-directed decoder in incorporating the attribute grammar for semantic restrictions, we will exploit the same encoder in Kusner et al.
(2017) for a fair comparison later.
We provide a brief introduction to the particular encoder model used in Kusner et al.
(2017) for a self-contained purpose.
Given a program or a SMILES sequence, we obtain the corresponding parse tree using CFG and decompose it into a sequence of productions through a pre-order traversal on the tree.
Then, we convert these productions into one-hot indicator vectors, in which each dimension corresponds to one production in the grammar.
We will use a deep convolutional neural networks which maps this sequence of one-hot vectors to a continuous vector as the encoder.
3. M ODEL L EARNING
Our learning goal is to maximize the evidence lower bound in Eq 1.
Given the encoder, we can then map the structure input into latent space z .
The variational posterior q ( z | x ) is parameterized with
Gaussian distribution, where the mean and variance are the output of corresponding neural networks.
The prior of latent variable p ( z ) =
N (0 , I ) .
Since both the prior and posterior are Gaussian, we use the closed form of KL-divergence that was proposed in Kingma & Welling (2013).
In the decoding stage, our goal is to maximize p θ ( x | z ) .
Using the Equation (2), we can compute the corresponding conditional likelihood.
During training, the syntax and semantics constraints required in Algorithmcan be precomputed.
In practice, we observe no signiﬁcant time penalty measured in wall clock time compared to previous works.
R ELATED WORK
Generative models with discrete structured data have raised increasing interests among researchers in different domains.
The classical sequence to sequence model (Sutskever et al., 2014) and its variations have also been applied to molecules (G´omez-Bombarelli et al., 2016).
Since the model is quite ﬂexible, it is hard to generate valid structures with limited data.
Techniques including data augmentation (Bjerrum, 2017), active learning (Janz et al., 2017) and reinforcement learning (Guimaraes et al., 2017) have also been proposed to tackle this issue.
However, according to the empirical evaluations from Benhenda (2017), the validity is still not satisfactory.
Even when the validity is enforced, the models tend to overﬁt to simple structures while neglect the diversity.
Since the structured data often comes with formal grammars, it is very helpful to generate its parse tree derived from CFG, instead of generating sequence of tokens directly.
The Grammar
VAE(Kusner et al., 2017) introduced the CFG constrained decoder for simple math expression and SMILES string generation.
The rules are used to mask out invalid syntax such that the generated sequence is always from the language deﬁned by its CFG.
Parisotto et al.
(2016) uses a
RecursiveReverse-Recursive Neural Network (R3NN) to capture global context information while expanding with CFG production rules.
Although these works follow the syntax via CFG, the context sensitive information can only be captured using variants of sequence/tree RNNs (Alvarez-Melis &
Jaakkola, 2016; Dong & Lapata, 2016; Zhang et al., 2015), which may not be time and sample efﬁcient.
In our work, we capture the semantics with proposed stochastic lazy attributes when generating structured outputs.
By addressing the most common semantics to harness the deep networks, it can greatly reshape the output domain of decoder (Hu et al., 2016).
As a result, we can also get a better generative model for discrete structures.
E XPERIMENTS
We show the effectiveness of our proposed SD-VAE with applications in two domains, namely programs and molecules.
We compare our method with CVAE (G ´ omez-Bombarelli et al., 2016) and
GVAE (Kusner et al., 2017).
CVAE only takes character sequence information, while GVAE utilizes the context-free grammar.
To make a fair comparison, we closely follow the experimental protocols that were set up in Kusner et al.
The training details are included in Appendix B.
Our method gets signiﬁcantly better results than previous works.
It yields better reconstruction accuracy and prior validity by large margins, while also having comparative diversity of generated structures.
More importantly, the SD-VAE ﬁnds better solution in program and molecule regression and optimization tasks.
This demonstrates that the continuous latent space obtained by SD-VAE is also smoother and more discriminative.
5. S ETTINGS
Here we ﬁrst describe our datasets in detail.
The programs are represented as a list of statements.
Each statement is an atomic arithmetic operation on variables (labeled as v0 , v1 , · · · , v9 ) and/or immediate numbers ( 1 , 2 , . . .
Some examples are listed below:
[Equation]
Here v0 is always the input, and the variable speciﬁed by return (respectively v5 and v8 in the examples) is the output, therefore it actually represent univariate functions f : R → R .
Note that a correct program should, besides the context-free grammar speciﬁed in Appendix A.1, also respect the semantic constraints.
For example, a variable should be deﬁned before being referenced.
We randomly generate 130 , 000 programs, where each consisting of 1 to 5 valid statements.
Here the maximum number of decoding steps T = 80 .
We hold 2000 programs out for testing and the rest for training and validation.
For molecule experiments, we use the same dataset as in Kusner et al.
It contains 250 ,
SMILES strings, which are extracted from the ZINC database (G´omez-Bombarelli et al., 2016).
We use the same split as Kusner et al.
(2017), where 5000 SMILES strings are held out for testing.
Regarding the syntax constraints, we use the grammar speciﬁed in Appendix A.2, which is also the same as Kusner et al.
Here the maximum number of decoding steps T = 278 .
For our SD-VAE, we address some of the most common semantics:
Program semantics We address the following: a ) variables should be deﬁned before use, b ) program must return a variable, c ) number of statements should be less than 10.
Molecule semantics The SMILES semantics we addressed includes: a ) ringbonds should satisfy cross-serial dependencies, b ) explicit valence of atoms should not go beyond permitted.
For more details about the semantics of SMILES language, please refer to Appendix A.3.
5. R ECONSTRUCTION A CCURACY AND P RIOR V ALIDITY
[Table] [Table]
We also report the reconstruction % grouped by number
[Table] [Table]
4, 5) in parentheses.
We use the held-out dataset to measure the reconstruction accuracy of VAEs.
For prior validity, we ﬁrst sample the latent representations from prior distribution, and then evaluate how often the model can decode into a valid structure.
Since both encoding and decoding are stochastic in VAEs, we follow the Monte Carlo method used in Kusner et al.
(2017) to do estimation: a ) reconstruction: for each of the structured data in the held-out dataset, we encode it 10 times and decoded (for each encoded latent space representation) 25 times, and report the portion of decoded structures that are the same as the input ones; b ) validity of prior: we sample 1000 latent representations z ∼ N ( O, I ) .
For each of them we decode 100 times, and calculate the portion of 100, decoded results that corresponds to valid Program or SMILES sequences.
Program
We show in the left part of Table 1 that our model has near perfect reconstruction rate, and most importantly, a perfect valid decoding program from prior.
This huge improvement is due to our model that utilizes the full semantics that previous work ignores, thus in theory guarantees perfect valid prior and in practice enables high reconstruction success rate.
For a fair comparison, we run and tune the baselines in 10% of training data and report the best result.
In the same place we also report the reconstruction successful rate grouped by number of statements.
It is shown that our model keeps high rate even with the size of program growing.
SMILES
Since the settings are exactly the same, we include CVAE and GVAE results directly from Kusner et al.
We show in the right part of Table 1 that our model produces a much higher rate of successful reconstruction and ratio of valid prior.
Figure 8 in Appendix C.2 also demonstrates some decoded molecules from our method.
Note that the results we reported have not included the semantics speciﬁc to aromaticity into account.
If we use an alternative kekulized form of SMILES to train the model, then the valid portion of prior can go up to 97 .
5. B AYESIAN O PTIMIZATION
One important application of VAEs is to enable the optimization ( e.g. , ﬁnd new structures with better properties) of discrete structures in continuous latent space, and then use decoder to obtain the actual structures.
Following the protocol used in Kusner et al.
(2017), we use Bayesian Optimization (BO) to search the programs and molecules with desired properties in latent space.
Details about BO settings and parameters can be found in Appendix C.1.
Finding program
In this application the models are asked to ﬁnd the program which is most similar to the ground truth program.
Here the distance is measured by log(1 + MSE ) , where the
MSE (Mean Square Error) calculates the discrepancy of program outputs, given the 1000 different
[Figure]
inputs v0 sampled evenly in [ − 5 , 5] .
In Figure 4 we show that our method ﬁnds the best program to the ground truth one compared to CVAE and GVAE.
Molecules Here we optimize the drug properties of molecules.
In this problem, we ask the model to optimize for octanol-water partition coefﬁcients (a.k.a log P ), an important measurement of druglikeness of a given molecule.
As G ´ omez-Bombarelli et al.
(2016) suggests, for drug-likeness assessment log P is penalized by other properties including synthetic accessibility score (Ertl & Schuffenhauer, 2009).
In Figure 5 we show the the top-3 best molecules found by each method, where our method found molecules with better scores than previous works.
Also one can see the molecule structures found by SD-VAE are richer than baselines, where the latter ones mostly consist of chain structure.
[Figure]
5. P REDICTIVE PERFORMANCE OF LATENT REPRESENTATION
[Table]
The VAEs also provide a way to do unsupervised feature representation learning G´omez-Bombarelli et al.
In this section, we seek to to know how well our latent space predicts the properties of programs and molecules.
After the training of VAEs, we dump the latent vectors of each structured data, and train the sparse Gaussian Process with the target value (namely the error for programs and the drug-likeness for molecules) for regression.
We test the performance in the held-out test dataset.
In Table 2, we report the result in Log Likelihood (LL) and Regression Mean Square Error (RMSE), which show that our SD-VAE always produces latent space that are more discriminative than both
CVAE and GVAE baselines.
This also shows that, with a properly designed decoder, the quality of encoder will also be improved via end-to-end training.
[Table]
5. D IVERSITY OF GENERATED MOLECULES
Inspired by Benhenda (2017), here we measure the diversity of generated molecules as an assessment of the methods.
The intuition is that a good generative model should be able to generate diverse data and avoid mode collapse in the learned space.
We conduct this experiment in the SMILES dataset.
We ﬁrst sample 100 points from the prior distribution.
For each point, we associate it with a molecule, which is the most frequent occurring valid SMILES decoded (we use 50 decoding attempts since the decoding is stochastic).
We then, with one of the several molecular similarity metrics, compute the pairwise similarity and report the mean and standard deviation in Table 3.
We see both methods do not have the mode collapse problem, while producing similar diversity scores.
It indicates that although our method has more restricted decoding space than baselines, the diversity is not sacriﬁced.
This is because we never rule-out the valid molecules.
And a more compact decoding space leads to much higher probability in obtaining valid molecules.
5. V ISUALIZING THE L ATENT S PACE
We seek to visualize the latent space as an assessment of how well our generative model is able to produces a coherent and smooth space of program and molecules.
Program
Following Bowman et al.
, we visualize the latent space of program by interpolation between two programs.
More speciﬁcally, given two programs which are encoded to p a and p b respectively in the latent space, we pick 9 evenly interpolated points between them.
For each point, we pick the corresponding most decoded structure.
In Table 4 we compare our results with previous works.
Our SD-VAE can pass though points in the latent space that can be decoded into valid programs without error and with visually more smooth interpolation than previous works.
Meanwhile, CVAE makes both syntactic and semantic errors, and GVAE produces only semantic errors (reference of undeﬁned variables), but still in a considerable amount.
[Figure]
[Table]
+v8;return:v7 v4=exp(v0);v
=v7-8;v9=8*v3;v7=
v3+v8;return:v v8=sin(1);v2=v8/2;v8=v0/v9;v4=v4-v8;return:v v6=
exp(v0);v8=v6-4;v9=6*v6;v7=
v9+v8;return:v7 v4=exp(v0);v9=v6-8;v6=2*v5;v7=
v3+v8;return:v v6=exp(v0);v2=v6-4;v8=v0*v1;v7=v4+v8;return:v7 v6=exp(v0);v
=v6-4;v4=4*v6;v7=
v4+v8;return:v7 v6=exp(v0);v
=v6-4;v4=4*v8;v7=
v4+v8;return:v v6=
exp(v0);v8=v6-4;v4=4*v8;v7=
v4+v8;return:v v6=
exp(v0);v8=v6-4;v4=4*v8;v7=
v4+v8;return:v
Observe that when a model passes points in its latent space, our proposed both syntactic and semantic constraints while making visually more smooth interpolation.
In contrast,
CVAE makes both kinds of mistakes, GVAE avoids syntactic errors but still produces semantic errors, and both methods produce subjectively less smooth interpolations.
SMILES For molecules, we visualize the latent space in 2 dimensions.
We ﬁrst embed a random molecule from the dataset into latent space.
Then we randomly generate 2 orthogonal unit vectors
A .
To get the latent representation of neighborhood, we interpolate the 2-D grid and project back to latent space with pseudo inverse of A .
Finally we show decoded molecules.
In Figure 6, we present two of such grid visualizations.
Subjectively compared with ﬁgures in Kusner et al.
(2017), our visualization is characterized by having smooth differences between neighboring molecules, and more complicated decoded structures.
NH NC + SH N
NH NN + SH C +
N N N + H 2 N NHN OH NH
NH NN + NH 2 C + HO C
+
NH N ONH NNN NH N ONH NNN NH N ONH NN NH N NNN
NH N NNN NH N NNN
N NNN
NH N NNN NH N NNN
NHC + NN + SH N
NNH NN + OHC + OH
NO
NH NN + OH Cl
NH N NHNN N
NH N NHNSN
NHN NH NN NH N NNN
NH N NNN
NH N NNN NH N NNN
N NNN N NNN
NH N NNN
NH NH N NFCl
Cl O
NH N NNH 2 FCl O
NH N NH OH
N
NH N NH NNN NH N NHN
NH N NNN
NH N NNN NH N NNN
NH N NNN NH N NNN
N NNN N NNN
N NNN
NH O N NNH 2 F Cl O
NH N NHNOHC + OH SH
NH N NHN N
NH N NHNSN
NH N NNNN NH N NNN
NH N NNN NH N NNN
NH N NNN NH N NNN
N NNN N NNN
N NNNN
O N + HO Cl
NH NH NN
NH 2 O OH
NH N NHN N
NH N NNNN
NH N NNN NH N NNN
NH N NNN NH N NNN
NH N NNN NH N NNN
N NNN N NNN
N NNNN
N N OH C + Cl NOH
NH
O NO - H
NH N NN
O N NNN
NH N NNN NH N NNN
NH N NNN NH N NNN
NH N NNN NH N NNN
N NNN N NNN
N N NNNN N
NH OH O OH S
O NHON
O NNNN O NNN
NH NNN
NH N NNN NH N NNN
NH N NNN NH N NNN
S N NNN
N NNN
N NNN S N N N NNN
+
N ON
N N - O
O NNN
O NNN O NNN
O NNN O N NNN
NH N NNN NH N NNN
SN NNN
S N NHN N HO
N N NNN
NH
N N N
N O NN S
NO NNN SH NO NNN S
O NNN
O NNN O NNN
O NNN O N NNN
NHN NNN NHN NNN
NN NN NN
NH N N N
N N H
N NNN HS
NH
N NNN HS
NH
NO NNN S NO NNN S
O NNN
O NNN O NNN
O NNN
O N NNNN H H
S N NNN
NH N NN S H
S N NN S H
N N N N
N NNN Cl
N NNN HS
NH
N NNN HS
NH
NO NNN S NO NNN
O NNN O NNN
O NHN
O NN O N NN
S N N NN H S N N NN H
N N N HH
N NNN Cl H 2 N
N NNN Cl Cl
N NN N SHCl N NN N SHCl
NO NNN
NO NHN
O NHN O NHN
HO O NN
O N N H
S NO
+ H
OH N N NHH
OH N O NH 2 O
+ H
N NNN OH H 2 N
N NN N SHCl
N NN N SSH
N NNNN H N NH N HS
OH NO NHN
OH NO NHN
OH O NNOH + S
OH O NNN C - H
OH O NN H
OH NN ONH 2 N N H 2 N N O OH H
HO N O H 2 N O
+
O OONH + NH + F O OONH + NH + F
O NOHO C + NH 2+ O
O ONONHC + NH 2+ O
O ON NH + F
O O NH + FOH
O OCl NH + F O Cl NH + O F N
O F NH + O F N
O Cl O NH 2+ FFF
O Cl O NH 2+ FFF O Cl NH 2+ FFF
O Cl NH 3+ FFF
O OONH + NH + F O OONH + NH + F
OO
O ON NH + FF
O O NH + FFF O O NH + FFF
O
O
NH
+ FFF O
OCl NH + O FFF O
OF NH + FFF N
O F NH 2+ FFF N O F O NH 2+ FFF
O Cl NH 2+ FF
O Cl NH 3+ FFF
O SOO
NH + NH + FF
O OO C + C + FF O
O NH NH + FFF O
ON NH + FFF
O O NH + FFF
O O NH + FFF O O NH + FFF O O NH + FFF O OF NH + FFF N
O F NH + FFF N
O F O NH + FFF O F O NH + FFF O Cl
NH + F F N
O SOO C + NH 2+ FFF O O NHC + NH 2+ FFF
O ON NH + FFF
O O NH + FFF
O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O OF NH + FFF N
O F O NH + FFF O
HO
NH + FFF O Cl NH + FFF N
O SHOON NH + FFF
O
O ON NH 2+ OFF
O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF N
O F NH + FFF N
O HO O NH + FFF
O OH NH + FFF N H
O S NH NH + FFF
O O NH 2+ FFCl
O O NH 2+ FFF
O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF N
O OH NH + FFF N
O Cl NH + FFF N H
O SN NH + FF Cl S
O O NH 2+ FFCl
O O NH 2+ FFF
O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF N
O NH + FFF
O OH NH + FFF N H
O SHOONHN NH 2+ FFF N
O O NH 2+ FFCl
O O NH 2+ FFCl
O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O ONH + FFF
O O NH 2+ FFF
O S NH 2+ FF F
ONNSOON NH + FF NHN
O NH 2+ FFCl N
O O NH 2+ FFF
O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF
O
O
NH 2+ FFF H
O NH 2+ FFF N
O NSOONNH + FCl H 2 N
NNS N - NH 2+ FFCl NH
O O NH 2+ FFCl N
O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF O O NH + FFF
O O NH + FF
O O NH 2+ FF O O S NH 2+ FFF O NH + FFF N
NSHOONHN NH 2+ FF NHN
NNSHOHONHN NH 2+ F ON
N NH + F FNH O NH + FFF
NH
O O NH + FFF O O NH + FFF O O NH + FFF O O S
NH 2+ FFF O O S
NH 2+ FFF O O S NH 2+ FFF O O S
NH 2+ FFF O O NH 2+ FFF O NH + FFF
NSHOHONHN NH 2+ FOHNHNH 2 NSHOHONHN NH 2+ F ON
NNS NH
NH 2 + FFNH 2 NH
NN N NH + FFF
NH
O N N NH 2 + FFH 2 N N
O O N S
NH + FFH 2 N NH
O O NS NH + FFF
O O N S NH 2+ FFF O O N S
NH 2+ FFF O
O
NH
NH 2+ FFF O O NHNH 2+ FFF O
O
NH 2+ FFF
ONNH 2+ FFF
NSOONHN NH 2+ FFNNH NSHO + NH + FF NHN
N SH N - NH 2+ FF N NNSNH
NH + NHF NH
NN NHN NH + FOH
NH
NO N S
NH 2+ FFH 2 N
O OOS
O OO
O O N SNH 2+ FFF
O O N SNHNH + NHF F
O O NH 2+ F F O C - N
O C - N
C ONCLUSION
In this paper we propose a new method to tackle the challenge of addressing both syntax and semantic constraints in generative model for structured data.
The newly proposed stochastic lazy attribute presents a the systematical conversion from ofﬂine syntax and semantic check to online guidance for stochastic generation and empirically shows consistent and signiﬁcant improvement over previous models, while requiring similar computational cost as previous model.
In the future work, we would like to explore the reﬁnement of formalization on a more theoretical ground and investigate the application of such formalization on a more diverse set of data modality
Appendix A G RAMMAR A. G RAMMAR FOR P ROGRAM S YNTAX
The syntax grammar for program is a generative contest free grammar starting with (cid:104) program (cid:105)
[Table]
(cid:104) program (cid:105) → (cid:104) stat list (cid:105) (cid:104) stat list (cid:105) → (cid:104) stat (cid:105) ‘ ; ’ (cid:104)
[Table]
list (cid:105) | (cid:104) stat (cid:105) (cid:104) stat (cid:105) → (cid:104)
[Table]
(cid:105)
|
[Table]
(cid:105) (cid:104) assign
[Table]
→ (cid:104) lhs (cid:105)
‘ = ’ (cid:104) rhs
[Table]
(cid:104) return (cid:105) → ‘ return: ’ (cid:104) lhs
[Table]
(cid:104) lhs (cid:105) → (cid:104) var (cid:105) (cid:104) var (cid:105) → ‘ v ’
[Table]
var id
[Table]
digit
[Table]
→ ‘
[Table]
’ | ‘
[Table]
’ | ‘
[Table]
’ | ‘
[Table]
’ | ‘
[Table]
’ | ‘
[Table]
’ | ‘
[Table]
’ | ‘
[Table]
’ | ‘
[Table]
A. G RAMMAR FOR M OLECULE S YNTAX
Our syntax grammar for molecule is based on OpenSMILES standard, a context free grammar starting with (cid:104) s (cid:105)
[Table]
[Figure] [Figure]
[Table]
A. E XAMPLES OF SMILES SEMANTICS
Here we provide more explanations of the semantics constraints that contained in SMILES language for molecules.
Speciﬁcally, the semantics we addressed here are:
Ringbond matching: The ringbonds should come in pairs.
Each pair of ringbonds has an index and a bond-type associated.
What the SMILES semantics requires is exactly the same as the well-known cross-serial dependencies (CSD) in formal language.
CSD also appears in some natural languages, such as Dutch and Swiss-German.
Another example of CSD is a sequence of multiple different types of parentheses where each separately balanced disregarding the others.
See Figure 7 for an illustration.
Explicit valence control: Intuitively, the semantics requires that each atom cannot have too many bonds associated with it.
For example, a normal carbon atom has maximum valence of 4, which means associating a Carbon atom with two triple-bonds will violate the semantics.
A. D EPENDENCY GRAPH INTRODUCED BY ATTRIBUTE GRAMMAR
Suppose there is a production r = u 0 → u 1 u 2 . . .
u | β | ∈ R and an attribute u i .a
we denote the dependency set D r ( u i .a )
= { u j .b |
u j .b is required for calculating u i .a } .
The union of all dependency sets D ( att ) T =
(cid:83) r ∈T ,u i ∈
r D r ( u i .a ) induces a dependency graph, where nodes are the attributes and directed edges represents the dependency relationships between those attributes computation.
Here T is an (partial or full) instantiation of the generated syntax tree of grammar G .
Let D r ( u i ) =
{ u j |∃ a, b : u
j .b ∈ D r ( u i .a ) } and D T
= (cid:83) r ∈T ,u i ∈
r D r ( u i ) , that is, D T is constructed from D ( att ) T by merging nodes with the same symbol but different attributes, we call D ( att ) T is noncircular if the corresponding D T is noncircular.
In our paper, we assume the noncircular property of the dependency graph.
Such property will be exploited for top-down generation in our decoder.
B T RAINING D ETAILS
Since our proposed SD-VAE differentiate itself from previous works (CVAE, GVAE) on the formalization of syntax and semantics, we therefore use the same deep neural network model architecture for a fair comparison.
In encoder, we use 3-layer one-dimension convolution neural networks (CNNs) followed by a full connected layer, whose output would be fed into two separate afﬁne layers for producing µ and σ respectively as in reparameterization trick; and in decoder we use 3-layer
RNNs followed by a afﬁne layer activated by softmax that gives probability for each production rule.
In detail, we use 56 dimensions the latent space and the dimension of layers as the same number as in Kusner et al.
As for implementation, we use Kusner et al.
(2017)’s open sourced code for baselines, and implement our model in PyTorch framework 3 .
In a 10% validation set we tune the following hyper parameters and report the test result from setting with best valid loss.
For a fair comparison, all tunings are also conducted in the baselines.
We use ReconstructLoss + α KLDivergence as the loss function for training.
A natural setting is α = 1 , but Kusner et al.
(2017) suggested in their open-sourced implementation 4 that using α = 1 / LatentDimension would leads to better results.
We explore both settings.
C M ORE EXPERIMENT DETAILS
O NH ONH O
NH 2+
Target
O NH S OH NH 2+ S
Decoded:
O NH S O
NH 2+
Decoded:
O NH S OH NH 2+ S
Decoded:
O NH S O
NH 2+
Decoded:
NH + OH S
Br
Target
NH + OH S
Br
Decoded:
NH + OH S
Br
Decoded:
NH + OH S
Br
Decoded:
NH + OH S
Br
Decoded:
O O NH F
Target
O N O NH F
Decoded:
O N O NH F
Decoded:
O O NH F
Decoded:
O N O NH F
Decoded:
N NH O O Cl
Target
N NH O O Cl
Decoded:
N NH O O Cl
Decoded:
N NH O O Cl
Decoded:
NH O O Cl
Decoded:
O O O O O N O
Target
O O O O O N O
Decoded:
O O O O O N O
Decoded:
O O O O O N O
Decoded:
O
O O O O N O
Decoded:
N N NH
Target
N N NH
Decoded:
N N NH
Decoded:
O N NH
Decoded:
O N NH
Decoded:
NH N N N N
Target
NH N N N N
Decoded:
O N N N N
Decoded:
NH N N N N
Decoded:
NH N N N N
Decoded:
O O NN N NH +
Target
O O NN N NH +
Decoded:
O O NN N NH +
Decoded:
O O NN N NH +
Decoded:
O O NN N NH +
Decoded:
NH O NH O O N
Target
NH O NH O O N
Decoded:
NH O NH O O N
Decoded:
NH O NH O O N
Decoded:
NH O NH O O N
Decoded:
O NH N NH N N NH F
Target
O NH N NH N N NH F
Decoded:
O NH N NH N N NH F
Decoded:
O NH N NH N N NH F
Decoded:
O NH N NH N N NH F
Decoded:
N O O NH N Cl
O
Target
N O O NH N Cl
O
Decoded:
N O O NH N Cl
O
Decoded:
N O O NH N Cl
O
Decoded:
N O O NH N Cl
O
Decoded:
O O N N
N
Target
O O N N
N
Decoded:
O O N N
N
Decoded:
O O N N
N
Decoded:
O O N N
N
Decoded:
C. B AYESIAN OPTIMIZATION
The Bayesian optimization is used for searching latent vectors with desired target property.
For example, in symbolic program regression, we are interested in ﬁnding programs that can ﬁt the given input-output pairs; in drug discovery, we are aiming at ﬁnding molecules with maximum drug likeness.
To get a fair comparison with baseline algorithms, we follow the settings used in Kusner et al.
issues/
Speciﬁcally, we ﬁrst train the variational autoencoder in an unsupervised way.
After obtaining the generative model, we encode all the structures into latent space.
Then these vectors and corresponding property values ( i.e. , estimated errors for program, or drug likeness for molecule) are used to train a sparse Gaussian process with 500 inducing points.
This is used later for predicting properties in latent space.
Next, 5 iterations of batch Bayesian optimization with the expected improvement (EI) heuristic is used for proposing new latent vectors.
In each iteration, 50 latent vectors are proposed.
After the proposal, the newly found programs/molecules are then added to the batch for next round of iteration.
During the proposal of latent vectors in each iteration, we perform 100 rounds of decoding and pick the most frequent decoded structures.
This helps regulates the decoding due to randomness, as well as increasing the chance for baselines algorithms to propose valid ones.
C. R ECONTRUCTION
We visualize some reconstruction results of SMILES in Figure 8.
It can be observed that, in most cases the decoder successfully recover the exact origin input.
Due to the stochasticity of decoder, it may have some small variations.