From Language to Programs: Bridging Reinforcement Learning and Maximum Marginal Likelihood

Our goal is to learn a semantic parser that maps natural language utterances into executable programs when only indirect supervision is available: examples are labeled with the correct execution result, but not the program itself. Consequently, we must search the space of programs for those that output the correct result, while not being misled by spurious programs: incorrect programs that coincidentally output the correct result. We connect two common learning paradigms, reinforcement learning (RL) and maximum marginal likelihood (MML), and then present a new learning algorithm that combines the strengths of both. The new algorithm guards against spurious programs by combining the systematic search traditionally employed in MML with the randomized exploration of RL, and by updating parameters such that probability is spread more evenly across consistent programs. We apply our learning algorithm to a new neural semantic parser and show significant gains over existing state-of-the-art results on a recent context-dependent semantic parsing task.


Introduction
We are interested in learning a semantic parser that maps natural language utterances into executable programs (e.g., logical forms). For example, in Figure 1, a program corresponding to the utterance transforms an initial world state into a new world state. We would like to learn from indirect supervision, where each training example is only labeled with the correct output (e.g. a target world state), but not the program that produced that out-  Figure 1: The task is to map natural language utterances to a program that manipulates the world state. The correct program captures the true meaning of the utterances, while spurious programs arrive at the correct output for the wrong reasons. We develop methods to prevent the model from being drawn to spurious programs.
The process of constructing a program can be formulated as a sequential decision-making process, where feedback is only received at the end of the sequence when the completed program is executed. In the natural language processing literature, there are two common approaches for handling this situation: 1) reinforcement learning (RL), particularly the REINFORCE algorithm (Williams, 1992;Sutton et al., 1999), which maximizes the expected reward of a sequence of actions; and 2) maximum marginal likelihood (MML), which treats the sequence of actions as a latent variable, and then maximizes the marginal likelihood of observing the correct program output (Dempster et al., 1977).
While the two approaches have enjoyed success on many tasks, we found them to work poorly out of the box for our task. This is because in addition to the sparsity of correct programs, our task also requires weeding out spurious programs (Pasupat and : incorrect interpretations of the utterances that accidentally produce the correct output, as illustrated in Figure 1.
We show that MML and RL optimize closely related objectives. Furthermore, both MML and RL methods have a mechanism for exploring program space in search of programs that generate the correct output. We explain why this exploration tends to quickly concentrate around short spurious programs, causing the model to sometimes overlook the correct program. To address this problem, we propose RANDOMER, a new learning algorithm with two parts: First, we propose randomized beam search, an exploration strategy which combines the systematic beam search traditionally employed in MML with the randomized off-policy exploration of RL. This increases the chance of finding correct programs even when the beam size is small or the parameters are not pre-trained.
Second, we observe that even with good exploration, the gradients of both the RL and MML objectives may still upweight entrenched spurious programs more strongly than correct programs with low probability under the current model. We propose a meritocratic parameter update rule, a modification to the MML gradient update, which more equally upweights all programs that produce the correct output. This makes the model less likely to overfit spurious programs.
We apply RANDOMER to train a new neural semantic parser, which outputs programs in a stackbased programming language. We evaluate our resulting system on SCONE, the context-dependent semantic parsing dataset of Long et al. (2016). Our approach outperforms standard RL and MML methods in a direct comparison, and achieves new state-of-the-art results, improving over Long et al. (2016) in all three domains of SCONE, and by over 30% accuracy on the most challenging one.

Task
We consider the semantic parsing task in the SCONE dataset 1 (Long et al., 2016). As illustrated in Figure 1, each example consists of a world containing several objects (e.g., people), each with certain properties (e.g., shirt color and hat color). Given the initial world state w 0 and a sequence of M natural language utterances u = (u 1 , . . . , u M ), the task is to generate a program that manipulates the world state according to the utterances. Each utterance u m describes a single action that transforms the world state w m−1 into a new world state w m . For training, the system receives weakly supervised examples with input x = (u, w 0 ) and the target final world state y = w M .
The dataset includes 3 domains: ALCHEMY, TANGRAMS, and SCENE. The description of each domain can be found in Appendix B. The domains highlight different linguistic phenomena: ALCHEMY features ellipsis (e.g., "throw the rest out", "mix"); TANGRAMS features anaphora on actions (e.g., "repeat step 3", "bring it back"); and SCENE features anaphora on entities (e.g., "he moves back", ". . . to his left"). Each domain contains roughly 3,700 training and 900 test examples. Each example contains 5 utterances and is labeled with the target world state after each utterance, but not the target program.
Spurious programs. Given a training example (u, w 0 , w M ), our goal is to find the true underlying program z * which reflects the meaning of u. The constraint that z * must transform w 0 into w M , i.e. z(w 0 ) = w M , is not enough to uniquely identify the true z * , as there are often many z satisfying z(w 0 ) = w M : in our experiments, we found at least 1600 on average for each example. Almost all do not capture the meaning of u (see Figure 1). We refer to these incorrect z's as spurious programs. Such programs encourage the model to learn an incorrect mapping from language to program operations: e.g., the spurious program in Figure 1 would cause the model to learn that "man in the yellow hat" maps to hasShirt(red).
Spurious programs in SCONE. In this dataset, utterances often reference objects in different ways (e.g. a person can be referenced by shirt color, hat color, or position). Hence, any target programming language must also support these different reference strategies. As a result, even a single action such as moving a person to a target destination can be achieved by many different programs, each selecting the person and destination in a different way. Across multiple actions, the number of programs grows combinatorially. 2 Only a few programs actually implement the correct reference strategy as defined by the utterance. This problem would be more severe in any more general-purpose language (e.g. Python).

Model
We formulate program generation as a sequence prediction problem. We represent a program as a sequence of program tokens in postfix notation; for example, move(hasHat(yellow), leftOf(hasShirt(blue))) is linearized as yellow hasHat blue hasShirt leftOf move. This representation also allows us to incrementally execute programs from left to right using a stack: constants (e.g., yellow) are pushed onto the stack, while functions (e.g., hasHat) pop appropriate arguments from the stack and push back the computed result (e.g., the list of people with yellow hats). Appendix B lists the full set of program tokens, Z, and how they are executed. Note that each action always ends with an action token (e.g., move).
Given an input x = (u, w 0 ), the model generates program tokens z 1 , z 2 , . . . from left to right using a neural encoder-decoder model with attention (Bahdanau et al., 2015). Throughout the generation process, the model maintains an utterance pointer, m, initialized to 1. To generate z t , the model's encoder first encodes the utterance u m into a vector e m . Then, based on e m and previously generated tokens z 1:t−1 , the model's decoder defines a distribution p(z t | x, z 1:t−1 ) over the possible values of z t ∈ Z. The next token z t is sampled from this distribution. If an action token (e.g., move) is generated, the model increments the utterance pointer m. The process terminates when all M utterances are processed. The final probability of generating a particular program z = (z 1 , . . . , z T ) is p(z | x) = T t=1 p(z t | x, z 1:t−1 ). Encoder. The utterance u m under the pointer is encoded using a bidirectional LSTM: where Φ u (u m,i ) is the fixed GloVe word embedding (Pennington et al., 2014) of the ith word in u m . The final utterance embedding is the concatenation e m = [h F |um| ; h B 1 ]. Decoder. Unlike Bahdanau et al. (2015), which used a recurrent network for the decoder, we opt for a feed-forward network for simplicity. We use e m and an embedding f (z 1:t−1 ) of the previous execution history (described later) as inputs to compute an attention vector c t : Finally, after concatenating q t with c t , the distribution over the set Z of possible program tokens is computed via a softmax: Execution history embedding. We compare two options for f (z 1:t−1 ), our embedding of the execution history. A standard approach is to simply take the k most recent tokens z t−k:t−1 and concatenate their embeddings. We will refer to this as TOKENS and use k = 4 in our experiments.
We also consider a new approach which leverages our ability to incrementally execute programs using a stack. We summarize the execution history by embedding the state of the stack at time t − 1, achieved by concatenating the embeddings of all values on the stack. (We limit the maximum stack size to 3.) We refer to this as STACK.

Reinforcement learning versus maximum marginal likelihood
Having formulated our task as a sequence prediction problem, we must still choose a learning algorithm. We first compare two standard paradigms: reinforcement learning (RL) and maximum marginal likelihood (MML). In the next section, we propose a better alternative.

Comparing objective functions
Reinforcement learning. From an RL perspective, given a training example (x, y), a policy makes a sequence of decisions z = (z 1 , . . . , z T ), and then receives a reward at the end of the episode: R(z) = 1 if z executes to y and 0 otherwise (dependence on x and y has been omitted from the notation). We focus on policy gradient methods, in which a stochastic policy function is trained to maximize the expected reward. In our setup, p θ (z | x) is the policy (with parameters θ), and its expected reward on a given example (x, y) is where the sum is over all possible programs. The overall RL objective, J RL , is the expected reward across examples: G(x, y). (2) Maximum marginal likelihood. The MML perspective assumes that y is generated by a partially-observed random process: conditioned on x, a latent program z is generated, and conditioned on z, the observation y is generated. This implies the marginal likelihood: Note that since the execution of z is deterministic, p θ (y | z) = 1 if z executes to y and 0 otherwise. The log marginal likelihood of the data is then where To estimate our model parameters θ, we maximize J MML with respect to θ. With our choice of reward, the RL expected reward (1) is equal to the MML marginal probability (3). Hence the only difference between the two formulations is that in RL we optimize the sum of expected rewards (2), whereas in MML we optimize the product (5). 3

Comparing gradients
In both policy gradient and MML, the objectives are typically optimized via (stochastic) gradient ascent. The gradients of J RL and J MML are closely related. They both have the form: 3 Note that the log of the product in (5) does not equal the sum in (2). Taking a step in the direction of ∇ log p θ (z | x) upweights the probability of z, so we can heuristically think of the gradient as attempting to upweight each reward-earning program z by a gradient weight q(z). In Subsection 5.2, we argue why q MML is better at guarding against spurious programs, and propose an even better alternative.

Comparing gradient approximation strategies
It is often intractable to compute the gradient (6) because it involves taking an expectation over all possible programs. So in practice, the expectation is approximated.
In the policy gradient literature, Monte Carlo integration (MC) is the typical approximation strategy. For example, the popular REINFORCE algorithm (Williams, 1992) uses Monte Carlo sampling to compute an unbiased estimate of the gradient: and c is a baseline (Williams, 1992) used to reduce the variance of the estimate without altering its expectation.
In the MML literature for latent sequences, the expectation is typically approximated via numerical integration (NUM) instead: where the programs in S come from beam search.
Beam search. Beam search generates a set of programs via the following process. At step t of beam search, we maintain a beam B t of at most B search states. Each state s ∈ B t represents a partially constructed program, s = (z 1 , . . . , z t ) (the first t tokens of the program). For each state s in the beam, we generate all possible continuations, We then take the union of these continuations, cont(B t ) = s∈Bt cont(s). The new beam B t+1 is simply the highest scoring B continuations in cont(B t ), as scored by the policy, p θ (s | x). Search is halted after a fixed number of iterations or when there are no continuations possible. S is then the set of all complete programs discovered during beam search. We will refer to this as beam search MML (BS-MML).
In both policy gradient and MML, we think of the procedure used to produce the set of programs S as an exploration strategy which searches for programs that produce reward. One advantage of numerical integration is that it allows us to decouple the exploration strategy from the gradient weights assigned to each program.

Tackling spurious programs
In this section, we illustrate why spurious programs are problematic for the most commonly used methods in RL (REINFORCE) and MML (beam search MML). We describe two key problems and propose a solution to each, based on insights gained from our comparison of RL and MML in Section 4.

Spurious programs bias exploration
As mentioned in Section 4, REINFORCE and BS-MML both employ an exploration strategy to approximate their respective gradients. In both methods, exploration is guided by the current model policy, whereby programs with high probability under the current policy are more likely to be explored. A troubling implication is that programs with low probability under the current policy are likely to be overlooked by exploration.
If the current policy incorrectly assigns low probability to the correct program z * , it will likely fail to discover z * during exploration, and will consequently fail to upweight the probability of z * . This repeats on every gradient step, keeping the probability of z * perpetually low. The same feedback loop can also cause already highprobability spurious programs to gain even more probability. From this, we see that exploration is sensitive to initial conditions: the rich get richer, and the poor get poorer.
Since there are often thousands of spurious programs and only a few correct programs, spurious programs are usually found first. Once spurious programs get a head start, exploration increasingly biases towards them.
As a remedy, one could try initializing parameters such that the model puts a uniform distribution over all possible programs. A seemingly reasonable tactic is to initialize parameters such that the Spurious: move(hasShirt(red), 1) Correct: move(hasHat(yellow), leftOf(hasShirt(blue)))  Figure 2: Two possible paths in the tree of all possible programs. One path leads to the spurious program z (red) while the longer path leads to the correct program z * (gold). Each edge represents a decision and shows the probability of that decision under a uniform policy. The shorter program has two orders of magnitude higher probability. model policy puts near-uniform probability over the decisions at each time step. However, this causes shorter programs to have orders of magnitude higher probability than longer programs, as illustrated in Figure 2 and as we empirically observe. A more sophisticated approach might involve approximating the total number of programs reachable from each point in the programgenerating decision tree. However, we instead propose to reduce sensitivity to the initial distribution over programs.

Solution: randomized beam search
One solution to biased exploration is to simply rely less on the untrustworthy current policy. We can do this by injecting random noise into exploration.
In REINFORCE, a common solution is to sample from an -greedy variant of the current policy. On the other hand, MML exploration with beam search is deterministic. However, it has a key advantage over REINFORCE-style sampling: even if one program occupies almost all probability under the current policy (a peaky distribution), beam search will still use its remaining beam capacity to explore at least B − 1 other programs. In contrast, sampling methods will repeatedly visit the mode of the distribution.
To get the best of both worlds, we propose a simple -greedy randomized beam search. Like regular beam search, at iteration t we compute the set of all continuations cont(B t ) and sort them by their model probability p θ (s | x). But instead of selecting the B highest-scoring continuations, we choose B continuations one by one without replacement from cont(B t ). When choosing a continuation from the remaining pool, we either uniformly sample a random continuation with probability , or pick the highest-scoring continuation in the pool with probability 1 − . Empirically, we find that this performs much better than both classic beam search and -greedy sampling (Table 3).

Spurious programs dominate gradients
In both RL and MML, even if exploration is perfect and the gradient is exactly computed, spurious programs can still be problematic.
Even if perfect exploration visits every program, we see from the gradient weights q(z) in (7) and (8) that programs are weighted proportional to their current policy probability. If a spurious program z has 100 times higher probability than z * as in Figure 2, the gradient will spend roughly 99% of its magnitude upweighting towards z and only 1% towards z * even though the two programs get the same reward.
This implies that it would take many updates for z * to catch up. In fact, z * may never catch up, depending on the gradient updates for other training examples. Simply increasing the learning rate is inadequate, as it would cause the model to take overly large steps towards z , potentially causing optimization to diverge.

Solution: the meritocratic update rule
To solve this problem, we want the upweighting to be more "meritocratic": any program that obtains reward should be upweighted roughly equally.
We first observe that J MML already improves over J RL in this regard. From (6), we see that the gradient weight q MML (z) is the policy distribution restricted to and renormalized over only rewardearning programs. This renormalization makes the gradient weight uniform across examples: even if all reward-earning programs for a particular example have very low model probability, their combined gradient weight z q MML (z) is always 1. In our experiments, J MML performs significantly better than J RL (Table 4).
However, while J MML assigns uniform weight across examples, it is still not uniform over the programs within each example. Hence we propose a new update rule which goes one step further in pursuing uniform updates. Extending q MML (z), we define a β-smoothed version: When β = 0, our weighting is completely uniform across all reward-earning programs within an example while β = 1 recovers the original MML weighting. Our new update rule is to simply take a modified gradient step where q = q β . 4 We will refer to this as the β-meritocratic update rule.

Summary of the proposed approach
We described two problems 5 and their solutions: we reduce exploration bias using -greedy randomized beam search and perform more balanced optimization using the β-meritocratic parameter update rule. We call our resulting approach RAN-DOMER. Table 1 summarizes how RANDOMER combines desirable qualities from both REIN-FORCE and BS-MML.

Experiments
Evaluation. We evaluate our proposed methods on all three domains of the SCONE dataset. Accuracy is defined as the percentage of test examples where the model produces the correct final world state w M . All test examples have M = 5 (5utts), but we also report accuracy after processing the first 3 utterances (3utts). To control for the effects of randomness, we train 5 instances of each model with different random seeds. We report the median accuracy of the instances unless otherwise noted.
All models are implemented in TensorFlow (Abadi et al., 2015). Model parameters are randomly initialized (Glorot and Bengio, 2010), with no pre-training. We use the Adam optimizer (Kingma and Ba, 2014) (which is applied to the gradient in (6)), a learning rate of 0.001, a minibatch size of 8 examples (different from the beam size), and train until accuracy on the validation set converges (on average about 13,000 steps). We

Method Approximation of Eq [·]
Exploration strategy Gradient weight q(z) REINFORCE Monte Carlo integration independent sampling p θ (z | x) BS-MML numerical integration beam search p θ (z | x, R(z) = 0) RANDOMER numerical integration randomized beam search q β (z) Table 1: RANDOMER combines qualities of both REINFORCE (RL) and BS-MML. For approximating the expectation over q in the gradient, we use numerical integration as in BS-MML. Our exploration strategy is a hybrid of search (MML) and off-policy sampling (RL). Our gradient weighting is equivalent to MML when β = 1 and more "meritocratic" than both MML and REINFORCE for lower values of β.
use fixed GloVe vectors (Pennington et al., 2014) to embed the words in each utterance.
Hyperparameters. For all models, we performed a grid search over hyperparameters to maximize accuracy on the validation set. Hyperparameters include the learning rate, the baseline in REINFORCE, -greediness and βmeritocraticness. For REINFORCE, we also experimented with a regression-estimated baseline (Ranzato et al., 2015), but found it to perform worse than a constant baseline.

Main results
Comparison to prior work. Table 2 compares RANDOMER to results from Long et al. (2016) as well as two baselines, REINFORCE and BS-MML (using the same neural model but different learning algorithms). Our approach achieves new state-of-the-art results by a significant margin, especially on the SCENE domain, which features the most complex program syntax. We report the results for REINFORCE, BS-MML, and RAN-DOMER on the seed and hyperparameters that achieve the best validation accuracy. We note that REINFORCE performs very well on TANGRAMS but worse on ALCHEMY and very poorly on SCENE. This might be because the program syntax for TANGRAMS is simpler than the other two: there is no other way to refer to objects except by index.
We also found that REINFORCE requiredgreedy exploration to make any progress. Using -greedy greatly skews the Monte Carlo approximation of ∇J RL , making it more uniformly weighted over programs in a similar spirit to using β-meritocratic gradient weights q β . However, q β increases uniformity over reward-earning programs only, rather than over all programs.
Effect of randomized beam search. Table 3 shows that -greedy randomized beam search consistently outperforms classic beam search. Even when we increase the beam size of classic beam ALCHEMY   search to 128, it still does not surpass randomized beam search with a beam of 32, and further increases yield no additional improvement.
Effect of β-meritocratic updates. Table 4 evaluates the impact of β-meritocratic parameter updates (gradient weight q β ). More uniform upweighting across reward-earning programs leads to higher accuracy and fewer spurious programs, especially in SCENE. However, no single value of β performs best over all domains. Choosing the right value of β in RANDOMER significantly accelerates training. Figure 3 illustrates that while β = 0 and β = 1 ultimately achieve similar accuracy on ALCHEMY, β = 0 reaches good performance in half the time.
Since lowering β reduces trust in the model policy, β < 1 helps in early training when the current policy is untrustworthy. However, as it grows more trustworthy, β < 1 begins to pay a price for ignoring it. Hence, it may be worthwhile to anneal β towards 1 over time.   Effect of execution history embedding. Table 5 compares our two proposals for embedding the execution history: TOKENS and STACK. STACK performs better in the two domains where an object can be referenced in multiple ways (SCENE and ALCHEMY). STACK directly embeds objects on the stack, invariant to the way in which they were pushed onto the stack, unlike TOKENS. We hypothesize that this invariance increases robustness to spurious behavior: if a program accidentally pushes the right object onto the stack via spurious means, the model can still learn the remaining steps of the program without conditioning on a spurious history.
Fitting vs overfitting the training data. Table 6 reveals that BS-MML and RANDOMER use different strategies to fit the training data. On the depicted training example, BS-MML actually achieves higher expected reward / marginal probability than RANDOMER, but it does so by putting most of its probability on a spurious programa form of overfitting. In contrast, RANDOMER spreads probability mass over multiple rewardearning programs, including the correct ones. As a consequence of overfitting, we observed at test time that BS-MML only references people by positional indices instead of by shirt or hat color, whereas RANDOMER successfully learns to use multiple reference strategies.

Related work and discussion
Semantic parsing from indirect supervision. Our work is motivated by the classic problem of learning semantic parsers from indirect supervision (Clarke et al., 2010;Liang et al., 2011; and Zettlemoyer, 2011and Zettlemoyer, , 2013Reddy et al., 2014;Pasupat and Liang, 2015). We are interested in the initial stages of training from scratch, where getting any training signal is difficult due to the combinatorially large search space. We also highlighted the problem of spurious programs which capture reward but give incorrect generalizations.
Maximum marginal likelihood with beam search (BS-MML) is traditionally used to learn semantic parsers from indirect supervision.
Reinforcement learning. Concurrently, there has been a recent surge of interest in reinforcement learning, along with the wide application of the classic REINFORCE algorithm (Williams, 1992)-to troubleshooting (Branavan et al., 2009), dialog generation (Li et al., 2016), game playing (Narasimhan et al., 2015), coreference resolution (Clark and Manning, 2016), machine translation , and even semantic parsing (Liang et al., 2017). Indeed, the challenge of training semantic parsers from indirect supervision is perhaps better captured by the notion of sparse rewards in reinforcement learning.
The RL answer would be better exploration, which can take many forms including simple action-dithering such as -greedy, entropy regularization (Williams and Peng, 1991), Monte Carlo tree search (Coulom, 2006), randomized value functions (Osband et al., 2014(Osband et al., , 2016, and methods which prioritize learning environment dynamics (Duff, 2002) or under-explored states (Kearns and Singh, 2002;Bellemare et al., 2016;Nachum et al., 2016). The majority of these methods employ Monte Carlo sampling for exploration. In Utterance: the man in the purple shirt and red hat moves just to the right of the man in the red shirt and yellow hat program prob RANDOMER ( = 0.15, β = 0) * move(hasHat(red), rightOf(hasHat(red)))  contrast, we find randomized beam search to be more suitable in our setting, because it explores low-probability states even when the policy distribution is peaky. Our β-meritocratic update also depends on the fact that beam search returns an entire set of reward-earning programs rather than one, since it renormalizes over the reward-earning set. While similar to entropy regularization, βmeritocratic update is more targeted as it only increases uniformity of the gradient among rewardearning programs, rather than across all programs.
Our strategy of using randomized beam search and meritocratic updates lies closer to MML than RL, but this does not imply that RL has nothing to offer in our setting. With the simple connection between RL and MML we established, much of the literature on exploration and variance reduction in RL can be directly applied to MML problems. Of special interest are methods which incorporate a value function such as actor-critic.
Maximum likelihood and RL. It is tempting to group our approach with sequence learning methods which interpolate between supervised learning and reinforcement learning (Ranzato et al., 2015;Venkatraman et al., 2015;Ross et al., 2011;Levine, 2014). These methods generally seek to make RL training easier by pre-training or "warm-starting" with fully supervised learning. This requires each training example to be labeled with a reasonably correct output sequence. In our setting, this would amount to labeling each example with the correct program, which is not known. Hence, these methods cannot be directly applied.
Without access to correct output sequences, we cannot directly maximize likelihood, and instead resort to maximizing the marginal likelihood (MML). Rather than proposing MML as a form of pre-training, we argue that MML is a superior substitute for the standard RL objective, and that the β-meritocratic update is even better.
Simulated annealing. Our β-meritocratic update employs exponential smoothing, which bears resemblance to the simulated annealing strategy of Och (2003); Smith and Eisner (2006); Shen et al. (2015). However, a key difference is that these methods smooth the objective function whereas we smooth an expectation in the gradient. To underscore the difference, we note that fixing β = 0 in our method (total smoothing) is quite effective, whereas total smoothing in the simulated annealing methods would correspond to a completely flat objective function, and an uninformative gradient of zero everywhere.
Neural semantic parsing. There has been recent interest in using recurrent neural networks for semantic parsing, both for modeling logical forms (Dong and Lapata, 2016;Jia and Liang, 2016;Liang et al., 2017) and for end-to-end execution (Yin et al., 2015;Neelakantan et al., 2016). We develop a neural model for the context-dependent setting, which is made possible by a new stackbased language similar to Riedel et al. (2016). P. Yin, Z. Lu, H. Li, and B. Kao. 2015. Neural enquirer: Learning to query tables. arXiv preprint arXiv:1512.00965 .